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

11 files changed, 1322 insertions, 1358 deletions

diff --git a/Bugzilla/WebService/Server/JSONRPC.pm b/Bugzilla/WebService/Server/JSONRPC.pm
index 12a3143cc..ef00737ad 100644
--- a/Bugzilla/WebService/Server/JSONRPC.pm
+++ b/Bugzilla/WebService/Server/JSONRPC.pm
@@ -12,16 +12,17 @@ use strict;
 use warnings;
 
 use Bugzilla::WebService::Server;
-BEGIN {
-    our @ISA = qw(Bugzilla::WebService::Server);
 
-    if (eval { require JSON::RPC::Server::CGI }) {
-        unshift(@ISA, 'JSON::RPC::Server::CGI');
-    }
-    else {
-        require JSON::RPC::Legacy::Server::CGI;
-        unshift(@ISA, 'JSON::RPC::Legacy::Server::CGI');
-    }
+BEGIN {
+  our @ISA = qw(Bugzilla::WebService::Server);
+
+  if (eval { require JSON::RPC::Server::CGI }) {
+    unshift(@ISA, 'JSON::RPC::Server::CGI');
+  }
+  else {
+    require JSON::RPC::Legacy::Server::CGI;
+    unshift(@ISA, 'JSON::RPC::Legacy::Server::CGI');
+  }
 }
 
 use Bugzilla::Error;
@@ -40,88 +41,92 @@ use Bugzilla::WebService::JSON;
 #####################################
 
 sub new {
-    my $class = shift;
-    my $self = $class->SUPER::new(@_);
-    Bugzilla->_json_server($self);
-    $self->dispatch(WS_DISPATCH);
-    $self->return_die_message(1);
-    return $self;
+  my $class = shift;
+  my $self  = $class->SUPER::new(@_);
+  Bugzilla->_json_server($self);
+  $self->dispatch(WS_DISPATCH);
+  $self->return_die_message(1);
+  return $self;
 }
 
 sub create_json_coder {
-    my $self = shift;
-    my $json = Bugzilla::WebService::JSON->new;
-    $json->allow_blessed(1);
-    $json->convert_blessed(1);
-    $json->allow_nonref(1);
-    # This may seem a little backwards, but what this really means is
-    # "don't convert our utf8 into byte strings, just leave it as a
-    # utf8 string."
-    $json->utf8(0) if Bugzilla->params->{'utf8'};
-    return $json;
+  my $self = shift;
+  my $json = Bugzilla::WebService::JSON->new;
+  $json->allow_blessed(1);
+  $json->convert_blessed(1);
+  $json->allow_nonref(1);
+
+  # This may seem a little backwards, but what this really means is
+  # "don't convert our utf8 into byte strings, just leave it as a
+  # utf8 string."
+  $json->utf8(0) if Bugzilla->params->{'utf8'};
+  return $json;
 }
 
 # Override the JSON::RPC method to return our CGI object instead of theirs.
 sub cgi { return Bugzilla->cgi; }
 
 sub response_header {
-    my $self = shift;
-    # The HTTP body needs to be bytes (not a utf8 string) for recent
-    # versions of HTTP::Message, but JSON::RPC::Server doesn't handle this
-    # properly. $_[1] is the HTTP body content we're going to be sending.
-    if (utf8::is_utf8($_[1])) {
-        utf8::encode($_[1]);
-        # Since we're going to just be sending raw bytes, we need to
-        # set STDOUT to not expect utf8.
-        disable_utf8();
-    }
-    return $self->SUPER::response_header(@_);
+  my $self = shift;
+
+  # The HTTP body needs to be bytes (not a utf8 string) for recent
+  # versions of HTTP::Message, but JSON::RPC::Server doesn't handle this
+  # properly. $_[1] is the HTTP body content we're going to be sending.
+  if (utf8::is_utf8($_[1])) {
+    utf8::encode($_[1]);
+
+    # Since we're going to just be sending raw bytes, we need to
+    # set STDOUT to not expect utf8.
+    disable_utf8();
+  }
+  return $self->SUPER::response_header(@_);
 }
 
 sub response {
-    my ($self, $response) = @_;
-    my $cgi = $self->cgi;
-
-    # Implement JSONP.
-    if (my $callback = $self->_bz_callback) {
-        my $content = $response->content;
-        if (blessed $content) {
-          $content = $content->encode;
-        }
-        # Prepend the JSONP response with /**/ in order to protect
-        # against possible encoding attacks (e.g., affecting Flash).
-        $response->content("/**/$callback($content)");
-    }
-
-    # Use $cgi->header properly instead of just printing text directly.
-    # This fixes various problems, including sending Bugzilla's cookies
-    # properly.
-    my $headers = $response->headers;
-    my @header_args;
-    foreach my $name ($headers->header_field_names) {
-        my @values = $headers->header($name);
-        $name =~ s/-/_/g;
-        foreach my $value (@values) {
-            push(@header_args, "-$name", $value);
-        }
-    }
-
-    # ETag support
-    my $etag = $self->bz_etag;
-    if ($etag && $cgi->check_etag($etag)) {
-        push(@header_args, "-ETag", $etag);
-        print $cgi->header(-status => '304 Not Modified', @header_args);
-    }
-    else {
-        push(@header_args, "-ETag", $etag) if $etag;
-        print $cgi->header(-status => $response->code, @header_args);
-        my $content = $response->content;
-        if (blessed $content) {
-          $content = $content->encode;
-          utf8::encode($content);
-        }
-        print $content;
-    }
+  my ($self, $response) = @_;
+  my $cgi = $self->cgi;
+
+  # Implement JSONP.
+  if (my $callback = $self->_bz_callback) {
+    my $content = $response->content;
+    if (blessed $content) {
+      $content = $content->encode;
+    }
+
+    # Prepend the JSONP response with /**/ in order to protect
+    # against possible encoding attacks (e.g., affecting Flash).
+    $response->content("/**/$callback($content)");
+  }
+
+  # Use $cgi->header properly instead of just printing text directly.
+  # This fixes various problems, including sending Bugzilla's cookies
+  # properly.
+  my $headers = $response->headers;
+  my @header_args;
+  foreach my $name ($headers->header_field_names) {
+    my @values = $headers->header($name);
+    $name =~ s/-/_/g;
+    foreach my $value (@values) {
+      push(@header_args, "-$name", $value);
+    }
+  }
+
+  # ETag support
+  my $etag = $self->bz_etag;
+  if ($etag && $cgi->check_etag($etag)) {
+    push(@header_args, "-ETag", $etag);
+    print $cgi->header(-status => '304 Not Modified', @header_args);
+  }
+  else {
+    push(@header_args, "-ETag", $etag) if $etag;
+    print $cgi->header(-status => $response->code, @header_args);
+    my $content = $response->content;
+    if (blessed $content) {
+      $content = $content->encode;
+      utf8::encode($content);
+    }
+    print $content;
+  }
 }
 
 # The JSON-RPC 1.1 GET specification is not so great--you can't specify
@@ -133,70 +138,69 @@ sub response {
 # Base64 encoded, because that is ridiculous and obnoxious for JavaScript
 # clients.
 sub retrieve_json_from_get {
-    my $self = shift;
-    my $cgi = $self->cgi;
-
-    my %input;
-
-    # Both version and id must be set before any errors are thrown.
-    if ($cgi->param('version')) {
-        $self->version(scalar $cgi->param('version'));
-        $input{version} = $cgi->param('version');
-    }
-    else {
-        $self->version('1.0');
-    }
-
-    # The JSON-RPC 2.0 spec says that any request that omits an id doesn't
-    # want a response. However, in an HTTP GET situation, it's stupid to
-    # expect all clients to specify some id parameter just to get a response,
-    # so we don't require it.
-    my $id;
-    if (defined $cgi->param('id')) {
-        $id = $cgi->param('id');
-    }
-    # However, JSON::RPC does require that an id exist in most cases, in
-    # order to throw proper errors. We use the installation's urlbase as
-    # the id, in this case.
-    else {
-        $id = Bugzilla->localconfig->{urlbase};
-    }
-    # Setting _bz_request_id here is required in case we throw errors early,
-    # before _handle.
-    $self->{_bz_request_id} = $input{id} = $id;
-
-    # _bz_callback can throw an error, so we have to set it here, after we're
-    # ready to throw errors.
-    $self->_bz_callback(scalar $cgi->param('callback'));
-
-    if (!$cgi->param('method')) {
-        ThrowUserError('json_rpc_get_method_required');
-    }
-    $input{method} = $cgi->param('method');
-
-    my $params;
-    if (defined $cgi->param('params')) {
-        local $@;
-        $params = eval {
-            $self->json->decode(scalar $cgi->param('params'))
-        };
-        if ($@) {
-            ThrowUserError('json_rpc_invalid_params',
-                           { params => scalar $cgi->param('params'),
-                             err_msg  => $@ });
-        }
-    }
-    elsif (!$self->version or $self->version ne '1.1') {
-        $params = [];
-    }
-    else {
-        $params = {};
-    }
-
-    $input{params} = $params;
-
-    my $json = $self->json->encode(\%input);
-    return $json;
+  my $self = shift;
+  my $cgi  = $self->cgi;
+
+  my %input;
+
+  # Both version and id must be set before any errors are thrown.
+  if ($cgi->param('version')) {
+    $self->version(scalar $cgi->param('version'));
+    $input{version} = $cgi->param('version');
+  }
+  else {
+    $self->version('1.0');
+  }
+
+  # The JSON-RPC 2.0 spec says that any request that omits an id doesn't
+  # want a response. However, in an HTTP GET situation, it's stupid to
+  # expect all clients to specify some id parameter just to get a response,
+  # so we don't require it.
+  my $id;
+  if (defined $cgi->param('id')) {
+    $id = $cgi->param('id');
+  }
+
+  # However, JSON::RPC does require that an id exist in most cases, in
+  # order to throw proper errors. We use the installation's urlbase as
+  # the id, in this case.
+  else {
+    $id = Bugzilla->localconfig->{urlbase};
+  }
+
+  # Setting _bz_request_id here is required in case we throw errors early,
+  # before _handle.
+  $self->{_bz_request_id} = $input{id} = $id;
+
+  # _bz_callback can throw an error, so we have to set it here, after we're
+  # ready to throw errors.
+  $self->_bz_callback(scalar $cgi->param('callback'));
+
+  if (!$cgi->param('method')) {
+    ThrowUserError('json_rpc_get_method_required');
+  }
+  $input{method} = $cgi->param('method');
+
+  my $params;
+  if (defined $cgi->param('params')) {
+    local $@;
+    $params = eval { $self->json->decode(scalar $cgi->param('params')) };
+    if ($@) {
+      ThrowUserError('json_rpc_invalid_params',
+        {params => scalar $cgi->param('params'), err_msg => $@});
+    }
+  }
+  elsif (!$self->version or $self->version ne '1.1') {
+    $params = [];
+  }
+  else {
+    $params = {};
+  }
+
+  $input{params} = $params;
+
+  my $json = $self->json->encode(\%input);
+  return $json;
 }
 
 #######################################
@@ -204,72 +208,76 @@ sub retrieve_json_from_get {
 #######################################
 
 sub type {
-    my ($self, $type, $value) = @_;
-
-    # This is the only type that does something special with undef.
-    if ($type eq 'boolean') {
-        return $value ? JSON::true : JSON::false;
-    }
-
-    return JSON::null if !defined $value;
-
-    my $retval = $value;
-
-    if ($type eq 'int') {
-        $retval = int($value);
-    }
-    if ($type eq 'double') {
-        $retval = 0.0 + $value;
-    }
-    elsif ($type eq 'string') {
-        # Forces string context, so that JSON will make it a string.
-        $retval = "$value";
-    }
-    elsif ($type eq 'dateTime') {
-        # ISO-8601 "YYYYMMDDTHH:MM:SS" with a literal T
-        $retval = $self->datetime_format_outbound($value);
-    }
-    elsif ($type eq 'base64') {
-        utf8::encode($value) if utf8::is_utf8($value);
-        $retval = encode_base64($value, '');
-    }
-    elsif ($type eq 'email' && Bugzilla->params->{'webservice_email_filter'}) {
-        $retval = email_filter($value);
-    }
-
-    return $retval;
+  my ($self, $type, $value) = @_;
+
+  # This is the only type that does something special with undef.
+  if ($type eq 'boolean') {
+    return $value ? JSON::true : JSON::false;
+  }
+
+  return JSON::null if !defined $value;
+
+  my $retval = $value;
+
+  if ($type eq 'int') {
+    $retval = int($value);
+  }
+  if ($type eq 'double') {
+    $retval = 0.0 + $value;
+  }
+  elsif ($type eq 'string') {
+
+    # Forces string context, so that JSON will make it a string.
+    $retval = "$value";
+  }
+  elsif ($type eq 'dateTime') {
+
+    # ISO-8601 "YYYYMMDDTHH:MM:SS" with a literal T
+    $retval = $self->datetime_format_outbound($value);
+  }
+  elsif ($type eq 'base64') {
+    utf8::encode($value) if utf8::is_utf8($value);
+    $retval = encode_base64($value, '');
+  }
+  elsif ($type eq 'email' && Bugzilla->params->{'webservice_email_filter'}) {
+    $retval = email_filter($value);
+  }
+
+  return $retval;
 }
 
 sub datetime_format_outbound {
-    my $self = shift;
-    # YUI expects ISO8601 in UTC time; including TZ specifier
-    return $self->SUPER::datetime_format_outbound(@_) . 'Z';
+  my $self = shift;
+
+  # YUI expects ISO8601 in UTC time; including TZ specifier
+  return $self->SUPER::datetime_format_outbound(@_) . 'Z';
 }
 
 sub handle_login {
-    my $self = shift;
-
-    # If we're being called using GET, we don't allow cookie-based or Env
-    # login, because GET requests can be done cross-domain, and we don't
-    # want private data showing up on another site unless the user
-    # explicitly gives that site their username and password. (This is
-    # particularly important for JSONP, which would allow a remote site
-    # to use private data without the user's knowledge, unless we had this
-    # protection in place.)
-    if ($self->request->method ne 'POST') {
-        # XXX There's no particularly good way for us to get a parameter
-        # to Bugzilla->login at this point, so we pass this information
-        # around using request_cache, which is a bit of a hack. The
-        # implementation of it is in Bugzilla::Auth::Login::Stack.
-        Bugzilla->request_cache->{auth_no_automatic_login} = 1;
-    }
-
-    my $path = $self->path_info;
-    my $class = $self->{dispatch_path}->{$path};
-    my $full_method = $self->_bz_method_name;
-    $full_method =~ /^\S+\.(\S+)/;
-    my $method = $1;
-    $self->SUPER::handle_login($class, $method, $full_method);
+  my $self = shift;
+
+  # If we're being called using GET, we don't allow cookie-based or Env
+  # login, because GET requests can be done cross-domain, and we don't
+  # want private data showing up on another site unless the user
+  # explicitly gives that site their username and password. (This is
+  # particularly important for JSONP, which would allow a remote site
+  # to use private data without the user's knowledge, unless we had this
+  # protection in place.)
+  if ($self->request->method ne 'POST') {
+
+    # XXX There's no particularly good way for us to get a parameter
+    # to Bugzilla->login at this point, so we pass this information
+    # around using request_cache, which is a bit of a hack. The
+    # implementation of it is in Bugzilla::Auth::Login::Stack.
+    Bugzilla->request_cache->{auth_no_automatic_login} = 1;
+  }
+
+  my $path        = $self->path_info;
+  my $class       = $self->{dispatch_path}->{$path};
+  my $full_method = $self->_bz_method_name;
+  $full_method =~ /^\S+\.(\S+)/;
+  my $method = $1;
+  $self->SUPER::handle_login($class, $method, $full_method);
 }
 
 ######################################
@@ -278,165 +286,165 @@ sub handle_login {
 
 # Store the ID of the current call, because Bugzilla::Error will need it.
 sub _handle {
-    my $self = shift;
-    my ($obj) = @_;
-    $self->{_bz_request_id} = $obj->{id};
+  my $self = shift;
+  my ($obj) = @_;
+  $self->{_bz_request_id} = $obj->{id};
 
-    my $result = $self->SUPER::_handle(@_);
+  my $result = $self->SUPER::_handle(@_);
 
-    # Set the ETag if not already set in the webservice methods.
-    my $etag = $self->bz_etag;
-    if (!$etag && ref $result) {
-        my $data = $self->json->decode($result)->{'result'};
-        $self->bz_etag($data);
-    }
+  # Set the ETag if not already set in the webservice methods.
+  my $etag = $self->bz_etag;
+  if (!$etag && ref $result) {
+    my $data = $self->json->decode($result)->{'result'};
+    $self->bz_etag($data);
+  }
 
-    return $result;
+  return $result;
 }
 
 # Make all error messages returned by JSON::RPC go into the 100000
 # range, and bring down all our errors into the normal range.
 sub _error {
-    my ($self, $id, $code) = (shift, shift, shift);
-    # All JSON::RPC errors are less than 1000.
-    if ($code < 1000) {
-        $code += 100000;
-    }
-    # Bugzilla::Error adds 100,000 to all *our* errors, so
-    # we know they came from us.
-    elsif ($code > 100000) {
-        $code -= 100000;
-    }
-
-    # We can't just set $_[1] because it's not always settable,
-    # in JSON::RPC::Server.
-    unshift(@_, $id, $code);
-    my $json = $self->SUPER::_error(@_);
-
-    # We want to always send the JSON-RPC 1.1 error format, although
-    # If we're not in JSON-RPC 1.1, we don't need the silly "name" parameter.
-    if (!$self->version or $self->version ne '1.1') {
-        my $object = $self->json->decode($json);
-        my $message = $object->{error};
-        # Just assure that future versions of JSON::RPC don't change the
-        # JSON-RPC 1.0 error format.
-        if (!ref $message) {
-            $object->{error} = {
-                code    => $code,
-                message => $message,
-            };
-            $json = $self->json->encode($object);
-        }
-    }
-    return $json;
+  my ($self, $id, $code) = (shift, shift, shift);
+
+  # All JSON::RPC errors are less than 1000.
+  if ($code < 1000) {
+    $code += 100000;
+  }
+
+  # Bugzilla::Error adds 100,000 to all *our* errors, so
+  # we know they came from us.
+  elsif ($code > 100000) {
+    $code -= 100000;
+  }
+
+  # We can't just set $_[1] because it's not always settable,
+  # in JSON::RPC::Server.
+  unshift(@_, $id, $code);
+  my $json = $self->SUPER::_error(@_);
+
+  # We want to always send the JSON-RPC 1.1 error format, although
+  # If we're not in JSON-RPC 1.1, we don't need the silly "name" parameter.
+  if (!$self->version or $self->version ne '1.1') {
+    my $object  = $self->json->decode($json);
+    my $message = $object->{error};
+
+    # Just assure that future versions of JSON::RPC don't change the
+    # JSON-RPC 1.0 error format.
+    if (!ref $message) {
+      $object->{error} = {code => $code, message => $message,};
+      $json = $self->json->encode($object);
+    }
+  }
+  return $json;
 }
 
 # This handles dispatching our calls to the appropriate class based on
 # the name of the method.
 sub _find_procedure {
-    my $self = shift;
+  my $self = shift;
 
-    my $method = shift;
-    $self->{_bz_method_name} = $method;
+  my $method = shift;
+  $self->{_bz_method_name} = $method;
 
-    # This tricks SUPER::_find_procedure into finding the right class.
-    $method =~ /^(\S+)\.(\S+)$/;
-    $self->path_info($1);
-    unshift(@_, $2);
+  # This tricks SUPER::_find_procedure into finding the right class.
+  $method =~ /^(\S+)\.(\S+)$/;
+  $self->path_info($1);
+  unshift(@_, $2);
 
-    return $self->SUPER::_find_procedure(@_);
+  return $self->SUPER::_find_procedure(@_);
 }
 
 # This is a hacky way to do something right before methods are called.
 # This is the last thing that JSON::RPC::Server::_handle calls right before
 # the method is actually called.
 sub _argument_type_check {
-    my $self = shift;
-    my $params = $self->SUPER::_argument_type_check(@_);
-
-    # JSON-RPC 1.0 requires all parameters to be passed as an array, so
-    # we just pull out the first item and assume it's an object.
-    my $params_is_array;
-    if (ref $params eq 'ARRAY') {
-        $params = $params->[0];
-        $params_is_array = 1;
-    }
-
-    taint_data($params);
-
-    # Now, convert dateTime fields on input.
-    $self->_bz_method_name =~ /^(\S+)\.(\S+)$/;
-    my ($class, $method) = ($1, $2);
-    my $pkg = $self->{dispatch_path}->{$class};
-    my @date_fields = @{ $pkg->DATE_FIELDS->{$method} || [] };
-    foreach my $field (@date_fields) {
-        if (defined $params->{$field}) {
-            my $value = $params->{$field};
-            if (ref $value eq 'ARRAY') {
-                $params->{$field} =
-                    [ map { $self->datetime_format_inbound($_) } @$value ];
-            }
-            else {
-                $params->{$field} = $self->datetime_format_inbound($value);
-            }
-        }
-    }
-    my @base64_fields = @{ $pkg->BASE64_FIELDS->{$method} || [] };
-    foreach my $field (@base64_fields) {
-        if (defined $params->{$field}) {
-            $params->{$field} = decode_base64($params->{$field});
-        }
-    }
-
-    # Update the params to allow for several convenience key/values
-    # use for authentication
-    fix_credentials($params, $self->cgi);
-
-    Bugzilla->input_params($params);
-
-    if ($self->request->method eq 'POST') {
-        # CSRF is possible via XMLHttpRequest when the Content-Type header
-        # is not application/json (for example: text/plain or
-        # application/x-www-form-urlencoded).
-        # application/json is the single official MIME type, per RFC 4627.
-        my $content_type = $self->cgi->content_type;
-        # The charset can be appended to the content type, so we use a regexp.
-        if ($content_type !~ m{^application/json(-rpc)?(;.*)?$}i) {
-            ThrowUserError('json_rpc_illegal_content_type',
-                            { content_type => $content_type });
-        }
-    }
-    else {
-        # When being called using GET, we don't allow calling
-        # methods that can change data. This protects us against cross-site
-        # request forgeries.
-        if (!grep($_ eq $method, $pkg->READ_ONLY)) {
-            ThrowUserError('json_rpc_post_only',
-                           { method => $self->_bz_method_name });
-        }
-    }
-
-    # Only allowed methods to be used from our whitelist
-    if (none { $_ eq $method} $pkg->PUBLIC_METHODS) {
-        ThrowCodeError('unknown_method', { method => $self->_bz_method_name });
-    }
-
-    # This is the best time to do login checks.
-    $self->handle_login();
-
-    # Bugzilla::WebService packages call internal methods like
-    # $self->_some_private_method. So we have to inherit from
-    # that class as well as this Server class.
-    my $new_class = ref($self) . '::' . $pkg;
-    my $isa_string = 'our @ISA = qw(' . ref($self) . " $pkg)";
-    eval "package $new_class;$isa_string;";
-    bless $self, $new_class;
-
-    if ($params_is_array) {
-        $params = [$params];
-    }
-
-    return $params;
+  my $self   = shift;
+  my $params = $self->SUPER::_argument_type_check(@_);
+
+  # JSON-RPC 1.0 requires all parameters to be passed as an array, so
+  # we just pull out the first item and assume it's an object.
+  my $params_is_array;
+  if (ref $params eq 'ARRAY') {
+    $params          = $params->[0];
+    $params_is_array = 1;
+  }
+
+  taint_data($params);
+
+  # Now, convert dateTime fields on input.
+  $self->_bz_method_name =~ /^(\S+)\.(\S+)$/;
+  my ($class, $method) = ($1, $2);
+  my $pkg = $self->{dispatch_path}->{$class};
+  my @date_fields = @{$pkg->DATE_FIELDS->{$method} || []};
+  foreach my $field (@date_fields) {
+    if (defined $params->{$field}) {
+      my $value = $params->{$field};
+      if (ref $value eq 'ARRAY') {
+        $params->{$field} = [map { $self->datetime_format_inbound($_) } @$value];
+      }
+      else {
+        $params->{$field} = $self->datetime_format_inbound($value);
+      }
+    }
+  }
+  my @base64_fields = @{$pkg->BASE64_FIELDS->{$method} || []};
+  foreach my $field (@base64_fields) {
+    if (defined $params->{$field}) {
+      $params->{$field} = decode_base64($params->{$field});
+    }
+  }
+
+  # Update the params to allow for several convenience key/values
+  # use for authentication
+  fix_credentials($params, $self->cgi);
+
+  Bugzilla->input_params($params);
+
+  if ($self->request->method eq 'POST') {
+
+    # CSRF is possible via XMLHttpRequest when the Content-Type header
+    # is not application/json (for example: text/plain or
+    # application/x-www-form-urlencoded).
+    # application/json is the single official MIME type, per RFC 4627.
+    my $content_type = $self->cgi->content_type;
+
+    # The charset can be appended to the content type, so we use a regexp.
+    if ($content_type !~ m{^application/json(-rpc)?(;.*)?$}i) {
+      ThrowUserError('json_rpc_illegal_content_type',
+        {content_type => $content_type});
+    }
+  }
+  else {
+    # When being called using GET, we don't allow calling
+    # methods that can change data. This protects us against cross-site
+    # request forgeries.
+    if (!grep($_ eq $method, $pkg->READ_ONLY)) {
+      ThrowUserError('json_rpc_post_only', {method => $self->_bz_method_name});
+    }
+  }
+
+  # Only allowed methods to be used from our whitelist
+  if (none { $_ eq $method } $pkg->PUBLIC_METHODS) {
+    ThrowCodeError('unknown_method', {method => $self->_bz_method_name});
+  }
+
+  # This is the best time to do login checks.
+  $self->handle_login();
+
+  # Bugzilla::WebService packages call internal methods like
+  # $self->_some_private_method. So we have to inherit from
+  # that class as well as this Server class.
+  my $new_class  = ref($self) . '::' . $pkg;
+  my $isa_string = 'our @ISA = qw(' . ref($self) . " $pkg)";
+  eval "package $new_class;$isa_string;";
+  bless $self, $new_class;
+
+  if ($params_is_array) {
+    $params = [$params];
+  }
+
+  return $params;
 }
 
 ##########################
@@ -445,22 +453,24 @@ sub _argument_type_check {
 
 # _bz_method_name is stored by _find_procedure for later use.
 sub _bz_method_name {
-    return $_[0]->{_bz_method_name};
+  return $_[0]->{_bz_method_name};
 }
 
 sub _bz_callback {
-    my ($self, $value) = @_;
-    if (defined $value) {
-        $value = trim($value);
-        # We don't use \w because we don't want to allow Unicode here.
-        if ($value !~ /^[A-Za-z0-9_\.\[\]]+$/) {
-            ThrowUserError('json_rpc_invalid_callback', { callback => $value });
-        }
-        $self->{_bz_callback} = $value;
-        # JSONP needs to be parsed by a JS parser, not by a JSON parser.
-        $self->content_type('text/javascript');
+  my ($self, $value) = @_;
+  if (defined $value) {
+    $value = trim($value);
+
+    # We don't use \w because we don't want to allow Unicode here.
+    if ($value !~ /^[A-Za-z0-9_\.\[\]]+$/) {
+      ThrowUserError('json_rpc_invalid_callback', {callback => $value});
     }
-    return $self->{_bz_callback};
+    $self->{_bz_callback} = $value;
+
+    # JSONP needs to be parsed by a JS parser, not by a JSON parser.
+    $self->content_type('text/javascript');
+  }
+  return $self->{_bz_callback};
 }
 
 1;
diff --git a/Bugzilla/WebService/Server/REST.pm b/Bugzilla/WebService/Server/REST.pm
index 5d8367410..781960c68 100644
--- a/Bugzilla/WebService/Server/REST.pm
+++ b/Bugzilla/WebService/Server/REST.pm
@@ -41,146 +41,146 @@ use Module::Runtime qw(require_module);
 ###########################
 
 sub handle {
-    my ($self)  = @_;
-
-    # Determine how the data should be represented. We do this early so
-    # errors will also be returned with the proper content type.
-    # If no accept header was sent or the content types specified were not
-    # matched, we default to the first type in the whitelist.
-    $self->content_type($self->_best_content_type(REST_CONTENT_TYPE_WHITELIST()));
-
-    # Using current path information, decide which class/method to
-    # use to serve the request. Throw error if no resource was found
-    # unless we were looking for OPTIONS
-    if (!$self->_find_resource($self->cgi->path_info)) {
-        if ($self->request->method eq 'OPTIONS'
-            && $self->bz_rest_options)
-        {
-            my $response = $self->response_header(STATUS_OK, "");
-            my $options_string = join(', ', @{ $self->bz_rest_options });
-            $response->header('Allow' => $options_string,
-                              'Access-Control-Allow-Methods' => $options_string);
-            return $self->response($response);
-        }
-
-        ThrowUserError("rest_invalid_resource",
-                       { path   => $self->cgi->path_info,
-                         method => $self->request->method });
+  my ($self) = @_;
+
+  # Determine how the data should be represented. We do this early so
+  # errors will also be returned with the proper content type.
+  # If no accept header was sent or the content types specified were not
+  # matched, we default to the first type in the whitelist.
+  $self->content_type($self->_best_content_type(REST_CONTENT_TYPE_WHITELIST()));
+
+  # Using current path information, decide which class/method to
+  # use to serve the request. Throw error if no resource was found
+  # unless we were looking for OPTIONS
+  if (!$self->_find_resource($self->cgi->path_info)) {
+    if ($self->request->method eq 'OPTIONS' && $self->bz_rest_options) {
+      my $response = $self->response_header(STATUS_OK, "");
+      my $options_string = join(', ', @{$self->bz_rest_options});
+      $response->header(
+        'Allow'                        => $options_string,
+        'Access-Control-Allow-Methods' => $options_string
+      );
+      return $self->response($response);
     }
 
-    # Dispatch to the proper module
-    my $class  = $self->bz_class_name;
-    my ($path) = $class =~ /::([^:]+)$/;
-    $self->path_info($path);
-    delete $self->{dispatch_path};
-    $self->dispatch({ $path => $class });
+    ThrowUserError("rest_invalid_resource",
+      {path => $self->cgi->path_info, method => $self->request->method});
+  }
 
-    my $params = $self->_retrieve_json_params;
+  # Dispatch to the proper module
+  my $class = $self->bz_class_name;
+  my ($path) = $class =~ /::([^:]+)$/;
+  $self->path_info($path);
+  delete $self->{dispatch_path};
+  $self->dispatch({$path => $class});
 
-    fix_credentials($params, $self->cgi);
+  my $params = $self->_retrieve_json_params;
 
-    # Fix includes/excludes for each call
-    rest_include_exclude($params);
+  fix_credentials($params, $self->cgi);
 
-    # Set callback name if content-type is 'application/javascript'
-    if ($params->{'callback'}
-        || $self->content_type eq 'application/javascript')
-    {
-        $self->_bz_callback($params->{'callback'} || 'callback');
-    }
+  # Fix includes/excludes for each call
+  rest_include_exclude($params);
 
-    Bugzilla->input_params($params);
+  # Set callback name if content-type is 'application/javascript'
+  if ($params->{'callback'} || $self->content_type eq 'application/javascript') {
+    $self->_bz_callback($params->{'callback'} || 'callback');
+  }
 
-    # Set the JSON version to 1.1 and the id to the current urlbase
-    # also set up the correct handler method
-    my $obj = {
-        version => '1.1',
-        id      => Bugzilla->localconfig->{urlbase},
-        method  => $self->bz_method_name,
-        params  => $params
-    };
+  Bugzilla->input_params($params);
 
-    # Execute the handler
-    my $result = $self->_handle($obj);
+  # Set the JSON version to 1.1 and the id to the current urlbase
+  # also set up the correct handler method
+  my $obj = {
+    version => '1.1',
+    id      => Bugzilla->localconfig->{urlbase},
+    method  => $self->bz_method_name,
+    params  => $params
+  };
 
-    if (!$self->error_response_header) {
-        return $self->response(
-            $self->response_header($self->bz_success_code || STATUS_OK, $result));
-    }
+  # Execute the handler
+  my $result = $self->_handle($obj);
 
-    $self->response($self->error_response_header);
+  if (!$self->error_response_header) {
+    return $self->response(
+      $self->response_header($self->bz_success_code || STATUS_OK, $result));
+  }
+
+  $self->response($self->error_response_header);
 }
 
 sub response {
-    my ($self, $response) = @_;
-
-    # If we have thrown an error, the 'error' key will exist
-    # otherwise we use 'result'. JSONRPC returns other data
-    # along with the result/error such as version and id which
-    # we will strip off for REST calls.
-    my $content = $response->content;
-
-    my $json_data = {};
-    if ($content) {
-        # Content is in bytes at this point and needs to be converted
-        # back to utf8 string.
-        enable_utf8();
-        utf8::decode($content) if !utf8::is_utf8($content);
-        $json_data = $self->json->decode($content);
-    }
-
-    my $result = {};
-    if (exists $json_data->{error}) {
-        $result = $json_data->{error};
-        $result->{error} = $self->type('boolean', 1);
-
-        $result->{documentation} = Bugzilla->params->{docs_urlbase} . "api/";
-        delete $result->{'name'}; # Remove JSONRPCError
-    }
-    elsif (exists $json_data->{result}) {
-        $result = $json_data->{result};
-    }
-
-    Bugzilla::Hook::process('webservice_rest_response',
-        { rpc => $self, result => \$result, response => $response });
-
-    # Access Control
-    my @allowed_headers = qw(accept content-type origin user-agent x-requested-with);
-    foreach my $header (keys %{ API_AUTH_HEADERS() }) {
-        # We want to lowercase and replace _ with -
-        my $translated_header = $header;
-        $translated_header =~ tr/A-Z_/a-z\-/;
-        push(@allowed_headers, $translated_header);
-    }
-    $response->header("Access-Control-Allow-Origin", "*");
-    $response->header("Access-Control-Allow-Headers", join(', ', @allowed_headers));
-
-    # ETag support
-    my $etag = $self->bz_etag;
-    $self->bz_etag($result) if !$etag;
-
-    # If accessing through web browser, then display in readable format
-    if ($self->content_type eq 'text/html') {
-        $result = $self->json->pretty->canonical->allow_nonref->encode($result);
-
-        my $template = Bugzilla->template;
-        $content = "";
-        $result->encode if blessed $result;
-        $template->process("rest.html.tmpl", { result => $result }, \$content)
-            || ThrowTemplateError($template->error());
-
-        $response->content_type('text/html');
-    }
-    else {
-        $content = $self->json->encode($result);
-    }
-
-    utf8::encode($content) if utf8::is_utf8($content);
-    disable_utf8();
-
-    $response->content($content);
-
-    $self->SUPER::response($response);
+  my ($self, $response) = @_;
+
+  # If we have thrown an error, the 'error' key will exist
+  # otherwise we use 'result'. JSONRPC returns other data
+  # along with the result/error such as version and id which
+  # we will strip off for REST calls.
+  my $content = $response->content;
+
+  my $json_data = {};
+  if ($content) {
+
+    # Content is in bytes at this point and needs to be converted
+    # back to utf8 string.
+    enable_utf8();
+    utf8::decode($content) if !utf8::is_utf8($content);
+    $json_data = $self->json->decode($content);
+  }
+
+  my $result = {};
+  if (exists $json_data->{error}) {
+    $result = $json_data->{error};
+    $result->{error} = $self->type('boolean', 1);
+
+    $result->{documentation} = Bugzilla->params->{docs_urlbase} . "api/";
+    delete $result->{'name'};    # Remove JSONRPCError
+  }
+  elsif (exists $json_data->{result}) {
+    $result = $json_data->{result};
+  }
+
+  Bugzilla::Hook::process('webservice_rest_response',
+    {rpc => $self, result => \$result, response => $response});
+
+  # Access Control
+  my @allowed_headers
+    = qw(accept content-type origin user-agent x-requested-with);
+  foreach my $header (keys %{API_AUTH_HEADERS()}) {
+
+    # We want to lowercase and replace _ with -
+    my $translated_header = $header;
+    $translated_header =~ tr/A-Z_/a-z\-/;
+    push(@allowed_headers, $translated_header);
+  }
+  $response->header("Access-Control-Allow-Origin", "*");
+  $response->header("Access-Control-Allow-Headers", join(', ', @allowed_headers));
+
+  # ETag support
+  my $etag = $self->bz_etag;
+  $self->bz_etag($result) if !$etag;
+
+  # If accessing through web browser, then display in readable format
+  if ($self->content_type eq 'text/html') {
+    $result = $self->json->pretty->canonical->allow_nonref->encode($result);
+
+    my $template = Bugzilla->template;
+    $content = "";
+    $result->encode if blessed $result;
+    $template->process("rest.html.tmpl", {result => $result}, \$content)
+      || ThrowTemplateError($template->error());
+
+    $response->content_type('text/html');
+  }
+  else {
+    $content = $self->json->encode($result);
+  }
+
+  utf8::encode($content) if utf8::is_utf8($content);
+  disable_utf8();
+
+  $response->content($content);
+
+  $self->SUPER::response($response);
 }
 
 #######################################
@@ -188,21 +188,21 @@ sub response {
 #######################################
 
 sub handle_login {
-    my $self = shift;
-    my $class = $self->bz_class_name;
-    my $method = $self->bz_method_name;
-    my $full_method = $class . "." . $method;
-    $full_method =~ s/^Bugzilla::WebService:://;
-
-    # We never want to create a new session unless the user is calling the
-    # login method.  Setting dont_persist_session makes
-    # Bugzilla::Auth::_handle_login_result() skip calling persist_login().
-    if ($full_method ne 'User.login') {
-        Bugzilla->request_cache->{dont_persist_session} = 1;
-    }
-
-    # Bypass JSONRPC::handle_login
-    Bugzilla::WebService::Server->handle_login($class, $method, $full_method);
+  my $self        = shift;
+  my $class       = $self->bz_class_name;
+  my $method      = $self->bz_method_name;
+  my $full_method = $class . "." . $method;
+  $full_method =~ s/^Bugzilla::WebService:://;
+
+  # We never want to create a new session unless the user is calling the
+  # login method.  Setting dont_persist_session makes
+  # Bugzilla::Auth::_handle_login_result() skip calling persist_login().
+  if ($full_method ne 'User.login') {
+    Bugzilla->request_cache->{dont_persist_session} = 1;
+  }
+
+  # Bypass JSONRPC::handle_login
+  Bugzilla::WebService::Server->handle_login($class, $method, $full_method);
 }
 
 ############################
@@ -212,79 +212,78 @@ sub handle_login {
 # We do not want to run Bugzilla::WebService::Server::JSONRPC->_find_prodedure
 # as it determines the method name differently.
 sub _find_procedure {
-    my $self = shift;
-    if ($self->isa('JSON::RPC::Server::CGI')) {
-        return JSON::RPC::Server::_find_procedure($self, @_);
-    }
-    else {
-        return JSON::RPC::Legacy::Server::_find_procedure($self, @_);
-    }
+  my $self = shift;
+  if ($self->isa('JSON::RPC::Server::CGI')) {
+    return JSON::RPC::Server::_find_procedure($self, @_);
+  }
+  else {
+    return JSON::RPC::Legacy::Server::_find_procedure($self, @_);
+  }
 }
 
 sub _argument_type_check {
-    my $self = shift;
-    my $params;
-
-    if ($self->isa('JSON::RPC::Server::CGI')) {
-        $params = JSON::RPC::Server::_argument_type_check($self, @_);
-    }
-    else {
-        $params = JSON::RPC::Legacy::Server::_argument_type_check($self, @_);
-    }
-
-    # JSON-RPC 1.0 requires all parameters to be passed as an array, so
-    # we just pull out the first item and assume it's an object.
-    my $params_is_array;
-    if (ref $params eq 'ARRAY') {
-        $params = $params->[0];
-        $params_is_array = 1;
-    }
-
-    taint_data($params);
-
-    # Now, convert dateTime fields on input.
-    my $method = $self->bz_method_name;
-    my $pkg = $self->{dispatch_path}->{$self->path_info};
-    my @date_fields = @{ $pkg->DATE_FIELDS->{$method} || [] };
-    foreach my $field (@date_fields) {
-        if (defined $params->{$field}) {
-            my $value = $params->{$field};
-            if (ref $value eq 'ARRAY') {
-                $params->{$field} =
-                    [ map { $self->datetime_format_inbound($_) } @$value ];
-            }
-            else {
-                $params->{$field} = $self->datetime_format_inbound($value);
-            }
-        }
+  my $self = shift;
+  my $params;
+
+  if ($self->isa('JSON::RPC::Server::CGI')) {
+    $params = JSON::RPC::Server::_argument_type_check($self, @_);
+  }
+  else {
+    $params = JSON::RPC::Legacy::Server::_argument_type_check($self, @_);
+  }
+
+  # JSON-RPC 1.0 requires all parameters to be passed as an array, so
+  # we just pull out the first item and assume it's an object.
+  my $params_is_array;
+  if (ref $params eq 'ARRAY') {
+    $params          = $params->[0];
+    $params_is_array = 1;
+  }
+
+  taint_data($params);
+
+  # Now, convert dateTime fields on input.
+  my $method      = $self->bz_method_name;
+  my $pkg         = $self->{dispatch_path}->{$self->path_info};
+  my @date_fields = @{$pkg->DATE_FIELDS->{$method} || []};
+  foreach my $field (@date_fields) {
+    if (defined $params->{$field}) {
+      my $value = $params->{$field};
+      if (ref $value eq 'ARRAY') {
+        $params->{$field} = [map { $self->datetime_format_inbound($_) } @$value];
+      }
+      else {
+        $params->{$field} = $self->datetime_format_inbound($value);
+      }
     }
-    my @base64_fields = @{ $pkg->BASE64_FIELDS->{$method} || [] };
-    foreach my $field (@base64_fields) {
-        if (defined $params->{$field}) {
-            $params->{$field} = decode_base64($params->{$field});
-        }
+  }
+  my @base64_fields = @{$pkg->BASE64_FIELDS->{$method} || []};
+  foreach my $field (@base64_fields) {
+    if (defined $params->{$field}) {
+      $params->{$field} = decode_base64($params->{$field});
     }
+  }
 
-    # This is the best time to do login checks.
-    $self->handle_login();
+  # This is the best time to do login checks.
+  $self->handle_login();
 
-    # Bugzilla::WebService packages call internal methods like
-    # $self->_some_private_method. So we have to inherit from
-    # that class as well as this Server class.
-    my $new_class = ref($self) . '::' . $pkg;
-    my $isa_string = 'our @ISA = qw(' . ref($self) . " $pkg)";
-    eval "package $new_class;$isa_string;";
-    bless $self, $new_class;
+  # Bugzilla::WebService packages call internal methods like
+  # $self->_some_private_method. So we have to inherit from
+  # that class as well as this Server class.
+  my $new_class  = ref($self) . '::' . $pkg;
+  my $isa_string = 'our @ISA = qw(' . ref($self) . " $pkg)";
+  eval "package $new_class;$isa_string;";
+  bless $self, $new_class;
 
-    # Allow extensions to modify the params post login
-    Bugzilla::Hook::process('webservice_rest_request',
-                            { rpc => $self, params => $params });
+  # Allow extensions to modify the params post login
+  Bugzilla::Hook::process('webservice_rest_request',
+    {rpc => $self, params => $params});
 
-    if ($params_is_array) {
-        $params = [$params];
-    }
+  if ($params_is_array) {
+    $params = [$params];
+  }
 
-    return $params;
+  return $params;
 }
 
 ###################
@@ -292,46 +291,46 @@ sub _argument_type_check {
 ###################
 
 sub bz_method_name {
-    my ($self, $method) = @_;
-    $self->{_bz_method_name} = $method if $method;
-    return $self->{_bz_method_name};
+  my ($self, $method) = @_;
+  $self->{_bz_method_name} = $method if $method;
+  return $self->{_bz_method_name};
 }
 
 sub bz_class_name {
-    my ($self, $class) = @_;
-    $self->{_bz_class_name} = $class if $class;
-    return $self->{_bz_class_name};
+  my ($self, $class) = @_;
+  $self->{_bz_class_name} = $class if $class;
+  return $self->{_bz_class_name};
 }
 
 sub bz_success_code {
-    my ($self, $value) = @_;
-    $self->{_bz_success_code} = $value if $value;
-    return $self->{_bz_success_code};
+  my ($self, $value) = @_;
+  $self->{_bz_success_code} = $value if $value;
+  return $self->{_bz_success_code};
 }
 
 sub bz_rest_params {
-    my ($self, $params) = @_;
-    $self->{_bz_rest_params} = $params if $params;
-    return $self->{_bz_rest_params};
+  my ($self, $params) = @_;
+  $self->{_bz_rest_params} = $params if $params;
+  return $self->{_bz_rest_params};
 }
 
 sub bz_rest_options {
-    my ($self, $options) = @_;
-    $self->{_bz_rest_options} = $options if $options;
-    return [ sort { $a cmp $b } @{ $self->{_bz_rest_options} } ];
+  my ($self, $options) = @_;
+  $self->{_bz_rest_options} = $options if $options;
+  return [sort { $a cmp $b } @{$self->{_bz_rest_options}}];
 }
 
 sub rest_include_exclude {
-    my ($params) = @_;
+  my ($params) = @_;
 
-    if (exists $params->{'include_fields'} && !ref $params->{'include_fields'}) {
-        $params->{'include_fields'} = [ split(/[\s+,]/, $params->{'include_fields'}) ];
-    }
-    if (exists $params->{'exclude_fields'} && !ref $params->{'exclude_fields'}) {
-        $params->{'exclude_fields'} = [ split(/[\s+,]/, $params->{'exclude_fields'}) ];
-    }
+  if (exists $params->{'include_fields'} && !ref $params->{'include_fields'}) {
+    $params->{'include_fields'} = [split(/[\s+,]/, $params->{'include_fields'})];
+  }
+  if (exists $params->{'exclude_fields'} && !ref $params->{'exclude_fields'}) {
+    $params->{'exclude_fields'} = [split(/[\s+,]/, $params->{'exclude_fields'})];
+  }
 
-    return $params;
+  return $params;
 }
 
 ##########################
@@ -339,187 +338,195 @@ sub rest_include_exclude {
 ##########################
 
 sub _retrieve_json_params {
-    my $self = shift;
-
-    # Make a copy of the current input_params rather than edit directly
-    my $params = {};
-    %{$params} = %{ Bugzilla->input_params };
-
-    # First add any parameters we were able to pull out of the path
-    # based on the resource regexp and combine with the normal URL
-    # parameters.
-    if (my $rest_params = $self->bz_rest_params) {
-        foreach my $param (keys %$rest_params) {
-            # If the param does not already exist or if the
-            # rest param is a single value, add it to the
-            # global params.
-            if (!exists $params->{$param} || !ref $rest_params->{$param}) {
-                $params->{$param} = $rest_params->{$param};
-            }
-            # If rest_param is a list then add any extra values to the list
-            elsif (ref $rest_params->{$param}) {
-                my @extra_values = ref $params->{$param}
-                                   ? @{ $params->{$param} }
-                                   : ($params->{$param});
-                $params->{$param}
-                    = [ uniq (@{ $rest_params->{$param} }, @extra_values) ];
-            }
-        }
+  my $self = shift;
+
+  # Make a copy of the current input_params rather than edit directly
+  my $params = {};
+  %{$params} = %{Bugzilla->input_params};
+
+  # First add any parameters we were able to pull out of the path
+  # based on the resource regexp and combine with the normal URL
+  # parameters.
+  if (my $rest_params = $self->bz_rest_params) {
+    foreach my $param (keys %$rest_params) {
+
+      # If the param does not already exist or if the
+      # rest param is a single value, add it to the
+      # global params.
+      if (!exists $params->{$param} || !ref $rest_params->{$param}) {
+        $params->{$param} = $rest_params->{$param};
+      }
+
+      # If rest_param is a list then add any extra values to the list
+      elsif (ref $rest_params->{$param}) {
+        my @extra_values
+          = ref $params->{$param} ? @{$params->{$param}} : ($params->{$param});
+        $params->{$param} = [uniq(@{$rest_params->{$param}}, @extra_values)];
+      }
+    }
+  }
+
+  # Any parameters passed in in the body of a non-GET request will override
+  # any parameters pull from the url path. Otherwise non-unique keys are
+  # combined.
+  if ($self->request->method ne 'GET') {
+    my $extra_params = {};
+
+    # We do this manually because CGI.pm doesn't understand JSON strings.
+    my $json = delete $params->{'POSTDATA'} || delete $params->{'PUTDATA'};
+    if ($json) {
+      eval { $extra_params = $self->json->utf8(0)->decode($json); };
+      if ($@) {
+        ThrowUserError('json_rpc_invalid_params', {err_msg => $@});
+      }
     }
 
-    # Any parameters passed in in the body of a non-GET request will override
-    # any parameters pull from the url path. Otherwise non-unique keys are
-    # combined.
-    if ($self->request->method ne 'GET') {
-        my $extra_params = {};
-        # We do this manually because CGI.pm doesn't understand JSON strings.
-        my $json = delete $params->{'POSTDATA'} || delete $params->{'PUTDATA'};
-        if ($json) {
-            eval { $extra_params = $self->json->utf8(0)->decode($json); };
-            if ($@) {
-                ThrowUserError('json_rpc_invalid_params', { err_msg  => $@ });
-            }
-        }
-
-        # Allow parameters in the query string if request was non-GET.
-        # Note: parameters in query string body override any matching
-        # parameters in the request body.
-        foreach my $param ($self->cgi->url_param()) {
-            $extra_params->{$param} = $self->cgi->url_param($param);
-        }
-
-        %{$params} = (%{$params}, %{$extra_params}) if %{$extra_params};
+    # Allow parameters in the query string if request was non-GET.
+    # Note: parameters in query string body override any matching
+    # parameters in the request body.
+    foreach my $param ($self->cgi->url_param()) {
+      $extra_params->{$param} = $self->cgi->url_param($param);
     }
 
-    return $params;
+    %{$params} = (%{$params}, %{$extra_params}) if %{$extra_params};
+  }
+
+  return $params;
 }
 
 sub preload {
-    require_module($_) for values %{ WS_DISPATCH() };
+  require_module($_) for values %{WS_DISPATCH()};
 }
 
 sub _find_resource {
-    my ($self, $path) = @_;
-
-    # Load in the WebService module from the dispatch map and then call
-    # $module->rest_resources to get the resources array ref.
-    my $resources = {};
-    foreach my $module (values %{ $self->{dispatch_path} }) {
-        next if !$module->can('rest_resources');
-        $resources->{$module} = $module->rest_resources;
-    }
-
-    Bugzilla::Hook::process('webservice_rest_resources',
-                            { rpc => $self, resources => $resources }) if Bugzilla::request_cache->{bzapi};
-
-    # Use the resources hash from each module loaded earlier to determine
-    # which handler to use based on a regex match of the CGI path.
-    # Also any matches found in the regex will be passed in later to the
-    # handler for possible use.
-    my $request_method = $self->request->method;
-
-    my (@matches, $handler_found, $handler_method, $handler_class);
-    foreach my $class (keys %{ $resources }) {
-        # The resource data for each module needs to be
-        # an array ref with an even number of elements
-        # to work correctly.
-        next if (ref $resources->{$class} ne 'ARRAY'
-                 || scalar @{ $resources->{$class} } % 2 != 0);
-
-        while (my $regex = shift @{ $resources->{$class} }) {
-            my $options_data = shift @{ $resources->{$class} };
-            next if ref $options_data ne 'HASH';
-
-            if (@matches = ($path =~ $regex)) {
-                # If a specific path is accompanied by a OPTIONS request
-                # method, the user is asking for a list of possible request
-                # methods for a specific path.
-                $self->bz_rest_options([ keys %{ $options_data } ]);
-
-                if ($options_data->{$request_method}) {
-                    my $resource_data = $options_data->{$request_method};
-                    $self->bz_class_name($class);
-
-                    # The method key/value can be a simple scalar method name
-                    # or a anonymous subroutine so we execute it here.
-                    my $method = ref $resource_data->{method} eq 'CODE'
-                                 ? $resource_data->{method}->($self)
-                                 : $resource_data->{method};
-                    $self->bz_method_name($method);
-
-                    # Pull out any parameters parsed from the URL path
-                    # and store them for use by the method.
-                    if ($resource_data->{params}) {
-                        $self->bz_rest_params($resource_data->{params}->(@matches));
-                    }
-
-                    # If a special success code is needed for this particular
-                    # method, then store it for later when generating response.
-                    if ($resource_data->{success_code}) {
-                        $self->bz_success_code($resource_data->{success_code});
-                    }
-                    $handler_found = 1;
-                }
-            }
-            last if $handler_found;
+  my ($self, $path) = @_;
+
+  # Load in the WebService module from the dispatch map and then call
+  # $module->rest_resources to get the resources array ref.
+  my $resources = {};
+  foreach my $module (values %{$self->{dispatch_path}}) {
+    next if !$module->can('rest_resources');
+    $resources->{$module} = $module->rest_resources;
+  }
+
+  Bugzilla::Hook::process('webservice_rest_resources',
+    {rpc => $self, resources => $resources})
+    if Bugzilla::request_cache->{bzapi};
+
+  # Use the resources hash from each module loaded earlier to determine
+  # which handler to use based on a regex match of the CGI path.
+  # Also any matches found in the regex will be passed in later to the
+  # handler for possible use.
+  my $request_method = $self->request->method;
+
+  my (@matches, $handler_found, $handler_method, $handler_class);
+  foreach my $class (keys %{$resources}) {
+
+    # The resource data for each module needs to be
+    # an array ref with an even number of elements
+    # to work correctly.
+    next
+      if (ref $resources->{$class} ne 'ARRAY'
+      || scalar @{$resources->{$class}} % 2 != 0);
+
+    while (my $regex = shift @{$resources->{$class}}) {
+      my $options_data = shift @{$resources->{$class}};
+      next if ref $options_data ne 'HASH';
+
+      if (@matches = ($path =~ $regex)) {
+
+        # If a specific path is accompanied by a OPTIONS request
+        # method, the user is asking for a list of possible request
+        # methods for a specific path.
+        $self->bz_rest_options([keys %{$options_data}]);
+
+        if ($options_data->{$request_method}) {
+          my $resource_data = $options_data->{$request_method};
+          $self->bz_class_name($class);
+
+          # The method key/value can be a simple scalar method name
+          # or a anonymous subroutine so we execute it here.
+          my $method
+            = ref $resource_data->{method} eq 'CODE'
+            ? $resource_data->{method}->($self)
+            : $resource_data->{method};
+          $self->bz_method_name($method);
+
+          # Pull out any parameters parsed from the URL path
+          # and store them for use by the method.
+          if ($resource_data->{params}) {
+            $self->bz_rest_params($resource_data->{params}->(@matches));
+          }
+
+          # If a special success code is needed for this particular
+          # method, then store it for later when generating response.
+          if ($resource_data->{success_code}) {
+            $self->bz_success_code($resource_data->{success_code});
+          }
+          $handler_found = 1;
         }
-        last if $handler_found;
+      }
+      last if $handler_found;
     }
+    last if $handler_found;
+  }
 
-    return $handler_found;
+  return $handler_found;
 }
 
 sub _best_content_type {
-    my ($self, @types) = @_;
-    return ($self->_simple_content_negotiation(@types))[0] || '*/*';
+  my ($self, @types) = @_;
+  return ($self->_simple_content_negotiation(@types))[0] || '*/*';
 }
 
 sub _simple_content_negotiation {
-    my ($self, @types) = @_;
-    my @accept_types = $self->_get_content_prefs();
-    # Return the types as-is if no accept header sent, since sorting will be a no-op.
-    if (!@accept_types) {
-        return @types;
-    }
-    my $score = sub { $self->_score_type(shift, @accept_types) };
-    return sort {$score->($b) <=> $score->($a)} @types;
+  my ($self, @types) = @_;
+  my @accept_types = $self->_get_content_prefs();
+
+ # Return the types as-is if no accept header sent, since sorting will be a no-op.
+  if (!@accept_types) {
+    return @types;
+  }
+  my $score = sub { $self->_score_type(shift, @accept_types) };
+  return sort { $score->($b) <=> $score->($a) } @types;
 }
 
 sub _score_type {
-    my ($self, $type, @accept_types) = @_;
-    my $score = scalar(@accept_types);
-    for my $accept_type (@accept_types) {
-        return $score if $type eq $accept_type;
-        $score--;
-    }
-    return 0;
+  my ($self, $type, @accept_types) = @_;
+  my $score = scalar(@accept_types);
+  for my $accept_type (@accept_types) {
+    return $score if $type eq $accept_type;
+    $score--;
+  }
+  return 0;
 }
 
 sub _get_content_prefs {
-    my $self = shift;
-    my $default_weight = 1;
-    my @prefs;
-
-    # Parse the Accept header, and save type name, score, and position.
-    my @accept_types = split /,/, $self->cgi->http('accept') || '';
-    my $order = 0;
-    for my $accept_type (@accept_types) {
-        my ($weight) = ($accept_type =~ /q=(\d\.\d+|\d+)/);
-        my ($name) = ($accept_type =~ m#(\S+/[^;]+)#);
-        next unless $name;
-        push @prefs, { name => $name, order => $order++};
-        if (defined $weight) {
-            $prefs[-1]->{score} = $weight;
-        } else {
-            $prefs[-1]->{score} = $default_weight;
-            $default_weight -= 0.001;
-        }
+  my $self           = shift;
+  my $default_weight = 1;
+  my @prefs;
+
+  # Parse the Accept header, and save type name, score, and position.
+  my @accept_types = split /,/, $self->cgi->http('accept') || '';
+  my $order = 0;
+  for my $accept_type (@accept_types) {
+    my ($weight) = ($accept_type =~ /q=(\d\.\d+|\d+)/);
+    my ($name)   = ($accept_type =~ m#(\S+/[^;]+)#);
+    next unless $name;
+    push @prefs, {name => $name, order => $order++};
+    if (defined $weight) {
+      $prefs[-1]->{score} = $weight;
+    }
+    else {
+      $prefs[-1]->{score} = $default_weight;
+      $default_weight -= 0.001;
     }
+  }
 
-    # Sort the types by score, subscore by order, and pull out just the name
-    @prefs = map {$_->{name}} sort {$b->{score} <=> $a->{score} ||
-                                    $a->{order} <=> $b->{order}} @prefs;
-    return @prefs;
+  # Sort the types by score, subscore by order, and pull out just the name
+  @prefs = map { $_->{name} }
+    sort { $b->{score} <=> $a->{score} || $a->{order} <=> $b->{order} } @prefs;
+  return @prefs;
 }
 
 1;
diff --git a/Bugzilla/WebService/Server/REST/Resources/Bug.pm b/Bugzilla/WebService/Server/REST/Resources/Bug.pm
index 26aec011c..34580368d 100644
--- a/Bugzilla/WebService/Server/REST/Resources/Bug.pm
+++ b/Bugzilla/WebService/Server/REST/Resources/Bug.pm
@@ -15,177 +15,172 @@ use Bugzilla::WebService::Constants;
 use Bugzilla::WebService::Bug;
 
 BEGIN {
-    *Bugzilla::WebService::Bug::rest_resources = \&_rest_resources;
-};
+  *Bugzilla::WebService::Bug::rest_resources = \&_rest_resources;
+}
 
 sub _rest_resources {
-    my $rest_resources = [
-        qr{^/bug$}, {
-            GET  => {
-                method => 'search',
-            },
-            POST => {
-                method => 'create',
-                status_code => STATUS_CREATED
-            }
-        },
-        qr{^/bug/$}, {
-            GET => {
-                method => 'get'
-            }
-        },
-        qr{^/bug/possible_duplicates$}, {
-            GET => {
-                method => 'possible_duplicates'
-            }
-        },
-        qr{^/bug/([^/]+)$}, {
-            GET => {
-                method => 'get',
-                params => sub {
-                    return { ids => [ $_[0] ] };
-                }
-            },
-            PUT => {
-                method => 'update',
-                params => sub {
-                    return { ids => [ $_[0] ] };
-                }
-            }
-        },
-        qr{^/bug/([^/]+)/comment$}, {
-            GET  => {
-                method => 'comments',
-                params => sub {
-                    return { ids => [ $_[0] ] };
-                }
-            },
-            POST => {
-                method => 'add_comment',
-                params => sub {
-                    return { id => $_[0] };
-                },
-                success_code => STATUS_CREATED
-            }
-        },
-        qr{^/bug/comment/(\d+)$}, {
-            GET => {
-                method => 'comments',
-                params => sub {
-                    return { comment_ids => [ $_[0] ] };
-                }
-            }
-        },
-        qr{^/bug/comment/tags/([^/]+)$}, {
-            GET => {
-                method => 'search_comment_tags',
-                params => sub {
-                    return { query => $_[0] };
-                },
-            },
-        },
-        qr{^/bug/comment/([^/]+)/tags$}, {
-            PUT => {
-                method => 'update_comment_tags',
-                params => sub {
-                    return { comment_id => $_[0] };
-                },
-            },
-        },
-        qr{^/bug/comment/render$}, {
-            POST => {
-                method => 'render_comment',
-            },
-        },
-        qr{^/bug/([^/]+)/history$}, {
-            GET => {
-                method => 'history',
-                params => sub {
-                    return { ids => [ $_[0] ] };
-                },
-            }
-        },
-        qr{^/bug/([^/]+)/attachment$}, {
-            GET  => {
-                method => 'attachments',
-                params => sub {
-                    return { ids => [ $_[0] ] };
-                }
-            },
-            POST => {
-                method => 'add_attachment',
-                params => sub {
-                    return { ids => [ $_[0] ] };
-                },
-                success_code => STATUS_CREATED
-            }
-        },
-        qr{^/bug/attachment/([^/]+)$}, {
-            GET => {
-                method => 'attachments',
-                params => sub {
-                    return { attachment_ids => [ $_[0] ] };
-                }
-            },
-            PUT => {
-                method => 'update_attachment',
-                params => sub {
-                    return { ids => [ $_[0] ] };
-                }
-            }
-        },
-        qr{^/field/bug$}, {
-            GET => {
-                method => 'fields',
-            }
-        },
-        qr{^/field/bug/([^/]+)$}, {
-            GET => {
-                method => 'fields',
-                params => sub {
-                    my $value = $_[0];
-                    my $param = 'names';
-                    $param = 'ids' if $value =~ /^\d+$/;
-                    return { $param => [ $_[0] ] };
-                }
-            }
-        },
-        qr{^/field/bug/([^/]+)/values$}, {
-            GET => {
-                method => 'legal_values',
-                params => sub {
-                    return { field => $_[0] };
-                }
-            }
-        },
-        qr{^/field/bug/([^/]+)/([^/]+)/values$}, {
-            GET => {
-                method => 'legal_values',
-                params => sub {
-                    return { field      => $_[0],
-                             product_id => $_[1] };
-                }
-            }
-        },
-        qr{^/flag_types/([^/]+)/([^/]+)$}, {
-            GET => {
-                method => 'flag_types',
-                params => sub {
-                    return { product   => $_[0],
-                             component => $_[1] };
-                }
-            }
-        },
-        qr{^/flag_types/([^/]+)$}, {
-            GET => {
-                method => 'flag_types',
-                params => sub {
-                    return { product => $_[0] };
-                }
-            }
+  my $rest_resources = [
+    qr{^/bug$},
+    {
+      GET  => {method => 'search',},
+      POST => {method => 'create', status_code => STATUS_CREATED}
+    },
+    qr{^/bug/$},
+    {GET => {method => 'get'}},
+    qr{^/bug/possible_duplicates$},
+    {GET => {method => 'possible_duplicates'}},
+    qr{^/bug/([^/]+)$},
+    {
+      GET => {
+        method => 'get',
+        params => sub {
+          return {ids => [$_[0]]};
+        }
+      },
+      PUT => {
+        method => 'update',
+        params => sub {
+          return {ids => [$_[0]]};
+        }
+      }
+    },
+    qr{^/bug/([^/]+)/comment$},
+    {
+      GET => {
+        method => 'comments',
+        params => sub {
+          return {ids => [$_[0]]};
+        }
+      },
+      POST => {
+        method => 'add_comment',
+        params => sub {
+          return {id => $_[0]};
+        },
+        success_code => STATUS_CREATED
+      }
+    },
+    qr{^/bug/comment/(\d+)$},
+    {
+      GET => {
+        method => 'comments',
+        params => sub {
+          return {comment_ids => [$_[0]]};
+        }
+      }
+    },
+    qr{^/bug/comment/tags/([^/]+)$},
+    {
+      GET => {
+        method => 'search_comment_tags',
+        params => sub {
+          return {query => $_[0]};
+        },
+      },
+    },
+    qr{^/bug/comment/([^/]+)/tags$},
+    {
+      PUT => {
+        method => 'update_comment_tags',
+        params => sub {
+          return {comment_id => $_[0]};
+        },
+      },
+    },
+    qr{^/bug/comment/render$},
+    {POST => {method => 'render_comment',},},
+    qr{^/bug/([^/]+)/history$},
+    {
+      GET => {
+        method => 'history',
+        params => sub {
+          return {ids => [$_[0]]};
+        },
+      }
+    },
+    qr{^/bug/([^/]+)/attachment$},
+    {
+      GET => {
+        method => 'attachments',
+        params => sub {
+          return {ids => [$_[0]]};
+        }
+      },
+      POST => {
+        method => 'add_attachment',
+        params => sub {
+          return {ids => [$_[0]]};
+        },
+        success_code => STATUS_CREATED
+      }
+    },
+    qr{^/bug/attachment/([^/]+)$},
+    {
+      GET => {
+        method => 'attachments',
+        params => sub {
+          return {attachment_ids => [$_[0]]};
+        }
+      },
+      PUT => {
+        method => 'update_attachment',
+        params => sub {
+          return {ids => [$_[0]]};
+        }
+      }
+    },
+    qr{^/field/bug$},
+    {GET => {method => 'fields',}},
+    qr{^/field/bug/([^/]+)$},
+    {
+      GET => {
+        method => 'fields',
+        params => sub {
+          my $value = $_[0];
+          my $param = 'names';
+          $param = 'ids' if $value =~ /^\d+$/;
+          return {$param => [$_[0]]};
+        }
+      }
+    },
+    qr{^/field/bug/([^/]+)/values$},
+    {
+      GET => {
+        method => 'legal_values',
+        params => sub {
+          return {field => $_[0]};
+        }
+      }
+    },
+    qr{^/field/bug/([^/]+)/([^/]+)/values$},
+    {
+      GET => {
+        method => 'legal_values',
+        params => sub {
+          return {field => $_[0], product_id => $_[1]};
+        }
+      }
+    },
+    qr{^/flag_types/([^/]+)/([^/]+)$},
+    {
+      GET => {
+        method => 'flag_types',
+        params => sub {
+          return {product => $_[0], component => $_[1]};
+        }
+      }
+    },
+    qr{^/flag_types/([^/]+)$},
+    {
+      GET => {
+        method => 'flag_types',
+        params => sub {
+          return {product => $_[0]};
         }
-    ];
-    return $rest_resources;
+      }
+    }
+  ];
+  return $rest_resources;
 }
 
 1;
diff --git a/Bugzilla/WebService/Server/REST/Resources/BugUserLastVisit.pm b/Bugzilla/WebService/Server/REST/Resources/BugUserLastVisit.pm
index 12290e84e..72aa0d40f 100644
--- a/Bugzilla/WebService/Server/REST/Resources/BugUserLastVisit.pm
+++ b/Bugzilla/WebService/Server/REST/Resources/BugUserLastVisit.pm
@@ -12,36 +12,32 @@ use strict;
 use warnings;
 
 BEGIN {
-    *Bugzilla::WebService::BugUserLastVisit::rest_resources = \&_rest_resources;
+  *Bugzilla::WebService::BugUserLastVisit::rest_resources = \&_rest_resources;
 }
 
 sub _rest_resources {
-    return [
-        # bug-id
-        qr{^/bug_user_last_visit/(\d+)$}, {
-            GET => {
-                method => 'get',
-                params => sub {
-                    return { ids => $_[0] };
-                },
-            },
-            POST => {
-                method => 'update',
-                params => sub {
-                    return { ids => $_[0] };
-                },
-            },
+  return [
+    # bug-id
+    qr{^/bug_user_last_visit/(\d+)$},
+    {
+      GET => {
+        method => 'get',
+        params => sub {
+          return {ids => $_[0]};
         },
-        # no bug-id
-        qr{^/bug_user_last_visit$}, {
-            GET => {
-                method => 'get',
-            },
-            POST => {
-                method => 'update',
-            },
+      },
+      POST => {
+        method => 'update',
+        params => sub {
+          return {ids => $_[0]};
         },
-    ];
+      },
+    },
+
+    # no bug-id
+    qr{^/bug_user_last_visit$},
+    {GET => {method => 'get',}, POST => {method => 'update',},},
+  ];
 }
 
 1;
diff --git a/Bugzilla/WebService/Server/REST/Resources/Bugzilla.pm b/Bugzilla/WebService/Server/REST/Resources/Bugzilla.pm
index 646355cd3..28872f698 100644
--- a/Bugzilla/WebService/Server/REST/Resources/Bugzilla.pm
+++ b/Bugzilla/WebService/Server/REST/Resources/Bugzilla.pm
@@ -15,48 +15,20 @@ use Bugzilla::WebService::Constants;
 use Bugzilla::WebService::Bugzilla;
 
 BEGIN {
-    *Bugzilla::WebService::Bugzilla::rest_resources = \&_rest_resources;
-};
+  *Bugzilla::WebService::Bugzilla::rest_resources = \&_rest_resources;
+}
 
 sub _rest_resources {
-    my $rest_resources = [
-        qr{^/version$}, {
-            GET  => {
-                method => 'version'
-            }
-        },
-        qr{^/extensions$}, {
-            GET => {
-                method => 'extensions'
-            }
-        },
-        qr{^/timezone$}, {
-            GET => {
-                method => 'timezone'
-            }
-        },
-        qr{^/time$}, {
-            GET => {
-                method => 'time'
-            }
-        },
-        qr{^/last_audit_time$}, {
-            GET => {
-                method => 'last_audit_time'
-            }
-        },
-        qr{^/parameters$}, {
-            GET => {
-                method => 'parameters'
-            }
-        },
-        qr{^/jobqueue_status$}, {
-            GET => {
-                method => 'jobqueue_status'
-            }
-        }
-    ];
-    return $rest_resources;
+  my $rest_resources = [
+    qr{^/version$},         {GET => {method => 'version'}},
+    qr{^/extensions$},      {GET => {method => 'extensions'}},
+    qr{^/timezone$},        {GET => {method => 'timezone'}},
+    qr{^/time$},            {GET => {method => 'time'}},
+    qr{^/last_audit_time$}, {GET => {method => 'last_audit_time'}},
+    qr{^/parameters$},      {GET => {method => 'parameters'}},
+    qr{^/jobqueue_status$}, {GET => {method => 'jobqueue_status'}}
+  ];
+  return $rest_resources;
 }
 
 1;
diff --git a/Bugzilla/WebService/Server/REST/Resources/Classification.pm b/Bugzilla/WebService/Server/REST/Resources/Classification.pm
index f20278f55..88ba028ba 100644
--- a/Bugzilla/WebService/Server/REST/Resources/Classification.pm
+++ b/Bugzilla/WebService/Server/REST/Resources/Classification.pm
@@ -15,22 +15,23 @@ use Bugzilla::WebService::Constants;
 use Bugzilla::WebService::Classification;
 
 BEGIN {
-    *Bugzilla::WebService::Classification::rest_resources = \&_rest_resources;
-};
+  *Bugzilla::WebService::Classification::rest_resources = \&_rest_resources;
+}
 
 sub _rest_resources {
-    my $rest_resources = [
-        qr{^/classification/([^/]+)$}, {
-            GET => {
-                method => 'get',
-                params => sub {
-                    my $param = $_[0] =~ /^\d+$/ ? 'ids' : 'names';
-                    return { $param => [ $_[0] ] };
-                }
-            }
+  my $rest_resources = [
+    qr{^/classification/([^/]+)$},
+    {
+      GET => {
+        method => 'get',
+        params => sub {
+          my $param = $_[0] =~ /^\d+$/ ? 'ids' : 'names';
+          return {$param => [$_[0]]};
         }
-    ];
-    return $rest_resources;
+      }
+    }
+  ];
+  return $rest_resources;
 }
 
 1;
diff --git a/Bugzilla/WebService/Server/REST/Resources/Elastic.pm b/Bugzilla/WebService/Server/REST/Resources/Elastic.pm
index 2f7c1eaa4..367dd9134 100644
--- a/Bugzilla/WebService/Server/REST/Resources/Elastic.pm
+++ b/Bugzilla/WebService/Server/REST/Resources/Elastic.pm
@@ -15,16 +15,13 @@ use Bugzilla::WebService::Constants;
 use Bugzilla::WebService::Elastic;
 
 BEGIN {
-    *Bugzilla::WebService::Elastic::rest_resources = \&_rest_resources;
-};
+  *Bugzilla::WebService::Elastic::rest_resources = \&_rest_resources;
+}
 
 sub _rest_resources {
-    my $rest_resources = [
-        qr{^/elastic/suggest_users$}, {
-            GET  => { method => 'suggest_users' },
-        },
-    ];
-    return $rest_resources;
+  my $rest_resources
+    = [qr{^/elastic/suggest_users$}, {GET => {method => 'suggest_users'},},];
+  return $rest_resources;
 }
 
 1;
diff --git a/Bugzilla/WebService/Server/REST/Resources/Group.pm b/Bugzilla/WebService/Server/REST/Resources/Group.pm
index 6e3d934eb..b6a1b9b34 100644
--- a/Bugzilla/WebService/Server/REST/Resources/Group.pm
+++ b/Bugzilla/WebService/Server/REST/Resources/Group.pm
@@ -15,38 +15,35 @@ use Bugzilla::WebService::Constants;
 use Bugzilla::WebService::Group;
 
 BEGIN {
-    *Bugzilla::WebService::Group::rest_resources = \&_rest_resources;
-};
+  *Bugzilla::WebService::Group::rest_resources = \&_rest_resources;
+}
 
 sub _rest_resources {
-    my $rest_resources = [
-        qr{^/group$}, {
-            GET  => {
-                method => 'get'
-            },
-            POST => {
-                method => 'create',
-                success_code => STATUS_CREATED
-            }
-        },
-        qr{^/group/([^/]+)$}, {
-            GET => {
-                method => 'get',
-                params => sub {
-                    my $param = $_[0] =~ /^\d+$/ ? 'ids' : 'names';
-                    return { $param => [ $_[0] ] };
-                }
-            },
-            PUT => {
-                method => 'update',
-                params => sub {
-                    my $param = $_[0] =~ /^\d+$/ ? 'ids' : 'names';
-                    return { $param => [ $_[0] ] };
-                }
-            }
+  my $rest_resources = [
+    qr{^/group$},
+    {
+      GET  => {method => 'get'},
+      POST => {method => 'create', success_code => STATUS_CREATED}
+    },
+    qr{^/group/([^/]+)$},
+    {
+      GET => {
+        method => 'get',
+        params => sub {
+          my $param = $_[0] =~ /^\d+$/ ? 'ids' : 'names';
+          return {$param => [$_[0]]};
+        }
+      },
+      PUT => {
+        method => 'update',
+        params => sub {
+          my $param = $_[0] =~ /^\d+$/ ? 'ids' : 'names';
+          return {$param => [$_[0]]};
         }
-    ];
-    return $rest_resources;
+      }
+    }
+  ];
+  return $rest_resources;
 }
 
 1;
diff --git a/Bugzilla/WebService/Server/REST/Resources/Product.pm b/Bugzilla/WebService/Server/REST/Resources/Product.pm
index 9ca6e3074..3222642c8 100644
--- a/Bugzilla/WebService/Server/REST/Resources/Product.pm
+++ b/Bugzilla/WebService/Server/REST/Resources/Product.pm
@@ -17,53 +17,41 @@ use Bugzilla::WebService::Product;
 use Bugzilla::Error;
 
 BEGIN {
-    *Bugzilla::WebService::Product::rest_resources = \&_rest_resources;
-};
+  *Bugzilla::WebService::Product::rest_resources = \&_rest_resources;
+}
 
 sub _rest_resources {
-    my $rest_resources = [
-        qr{^/product_accessible$}, {
-            GET => {
-                method => 'get_accessible_products'
-            }
-        },
-        qr{^/product_enterable$}, {
-            GET => {
-                method => 'get_enterable_products'
-            }
-        },
-        qr{^/product_selectable$}, {
-            GET => {
-                method => 'get_selectable_products'
-            }
-        },
-        qr{^/product$}, {
-            GET  => {
-                method => 'get'
-            },
-            POST => {
-                method => 'create',
-                success_code => STATUS_CREATED
-            }
-        },
-        qr{^/product/([^/]+)$}, {
-            GET => {
-                method => 'get',
-                params => sub {
-                    my $param = $_[0] =~ /^\d+$/ ? 'ids' : 'names';
-                    return { $param => [ $_[0] ] };
-                }
-            },
-            PUT => {
-                method => 'update',
-                params => sub {
-                    my $param = $_[0] =~ /^\d+$/ ? 'ids' : 'names';
-                    return { $param => [ $_[0] ] };
-                }
-            }
-        },
-    ];
-    return $rest_resources;
+  my $rest_resources = [
+    qr{^/product_accessible$},
+    {GET => {method => 'get_accessible_products'}},
+    qr{^/product_enterable$},
+    {GET => {method => 'get_enterable_products'}},
+    qr{^/product_selectable$},
+    {GET => {method => 'get_selectable_products'}},
+    qr{^/product$},
+    {
+      GET  => {method => 'get'},
+      POST => {method => 'create', success_code => STATUS_CREATED}
+    },
+    qr{^/product/([^/]+)$},
+    {
+      GET => {
+        method => 'get',
+        params => sub {
+          my $param = $_[0] =~ /^\d+$/ ? 'ids' : 'names';
+          return {$param => [$_[0]]};
+        }
+      },
+      PUT => {
+        method => 'update',
+        params => sub {
+          my $param = $_[0] =~ /^\d+$/ ? 'ids' : 'names';
+          return {$param => [$_[0]]};
+        }
+      }
+    },
+  ];
+  return $rest_resources;
 }
 
 1;
diff --git a/Bugzilla/WebService/Server/REST/Resources/User.pm b/Bugzilla/WebService/Server/REST/Resources/User.pm
index 6185237fb..ab5f78bde 100644
--- a/Bugzilla/WebService/Server/REST/Resources/User.pm
+++ b/Bugzilla/WebService/Server/REST/Resources/User.pm
@@ -15,71 +15,54 @@ use Bugzilla::WebService::Constants;
 use Bugzilla::WebService::User;
 
 BEGIN {
-    *Bugzilla::WebService::User::rest_resources = \&_rest_resources;
-};
+  *Bugzilla::WebService::User::rest_resources = \&_rest_resources;
+}
 
 sub _rest_resources {
-    my $rest_resources = [
-        qr{^/user/suggest$}, {
-            GET => {
-                method => 'suggest',
-            },
-        },
-        qr{^/valid_login$}, {
-            GET => {
-                method => 'valid_login'
-            }
-        },
-        qr{^/login$}, {
-            GET => {
-                method => 'login'
-            }
-        },
-        qr{^/logout$}, {
-            GET => {
-                method => 'logout'
-            }
-        },
-        qr{^/user$}, {
-            GET  => {
-                method => 'get'
-            },
-            POST => {
-                method => 'create',
-                success_code => STATUS_CREATED
-            }
-        },
-        qr{^/user/([^/]+)$}, {
-            GET => {
-                method => 'get',
-                params => sub {
-                    my $param = $_[0] =~ /^\d+$/ ? 'ids' : 'names';
-                    return { $param => [ $_[0] ] };
-                }
-            },
-            PUT => {
-                method => 'update',
-                params => sub {
-                    my $param = $_[0] =~ /^\d+$/ ? 'ids' : 'names';
-                    return { $param => [ $_[0] ] };
-                }
-            }
-        },
-        qr{^/user/mfa/([^/]+)/enroll$}, {
-            GET => {
-                method => 'mfa_enroll',
-                params => sub {
-                    return { provider => $_[0] };
-                }
-            },
-        },
-        qr{^/whoami$}, {
-            GET => {
-                method => 'whoami'
-            }
+  my $rest_resources = [
+    qr{^/user/suggest$},
+    {GET => {method => 'suggest',},},
+    qr{^/valid_login$},
+    {GET => {method => 'valid_login'}},
+    qr{^/login$},
+    {GET => {method => 'login'}},
+    qr{^/logout$},
+    {GET => {method => 'logout'}},
+    qr{^/user$},
+    {
+      GET  => {method => 'get'},
+      POST => {method => 'create', success_code => STATUS_CREATED}
+    },
+    qr{^/user/([^/]+)$},
+    {
+      GET => {
+        method => 'get',
+        params => sub {
+          my $param = $_[0] =~ /^\d+$/ ? 'ids' : 'names';
+          return {$param => [$_[0]]};
+        }
+      },
+      PUT => {
+        method => 'update',
+        params => sub {
+          my $param = $_[0] =~ /^\d+$/ ? 'ids' : 'names';
+          return {$param => [$_[0]]};
+        }
+      }
+    },
+    qr{^/user/mfa/([^/]+)/enroll$},
+    {
+      GET => {
+        method => 'mfa_enroll',
+        params => sub {
+          return {provider => $_[0]};
         }
-    ];
-    return $rest_resources;
+      },
+    },
+    qr{^/whoami$},
+    {GET => {method => 'whoami'}}
+  ];
+  return $rest_resources;
 }
 
 1;
diff --git a/Bugzilla/WebService/Server/XMLRPC.pm b/Bugzilla/WebService/Server/XMLRPC.pm
index 5ad50e91c..ca2d119de 100644
--- a/Bugzilla/WebService/Server/XMLRPC.pm
+++ b/Bugzilla/WebService/Server/XMLRPC.pm
@@ -23,99 +23,102 @@ use Bugzilla::Util;
 use List::MoreUtils qw(none);
 
 BEGIN {
-    # Allow WebService methods to call XMLRPC::Lite's type method directly
-    *Bugzilla::WebService::type = sub {
-        my ($self, $type, $value) = @_;
-        if ($type eq 'dateTime') {
-            # This is the XML-RPC implementation,  see the README in Bugzilla/WebService/.
-            # Our "base" implementation is in Bugzilla::WebService::Server.
-            if (defined $value) {
-                $value = Bugzilla::WebService::Server->datetime_format_outbound($value);
-                $value =~ s/-//g;
-            }
-            else {
-                my ($pkg, $file, $line) = caller;
-                my $class = ref $self;
-                ERROR("$class->type($type, undef) called from $pkg ($file line $line)");
-            }
-        }
-        elsif ($type eq 'email') {
-            $type = 'string';
-            if (Bugzilla->params->{'webservice_email_filter'}) {
-                $value = email_filter($value);
-            }
-        }
-        return XMLRPC::Data->type($type)->value($value);
-    };
-
-    # Add support for ETags into XMLRPC WebServices
-    *Bugzilla::WebService::bz_etag = sub {
-        return Bugzilla::WebService::Server->bz_etag($_[1]);
-    };
+  # Allow WebService methods to call XMLRPC::Lite's type method directly
+  *Bugzilla::WebService::type = sub {
+    my ($self, $type, $value) = @_;
+    if ($type eq 'dateTime') {
+
+      # This is the XML-RPC implementation,  see the README in Bugzilla/WebService/.
+      # Our "base" implementation is in Bugzilla::WebService::Server.
+      if (defined $value) {
+        $value = Bugzilla::WebService::Server->datetime_format_outbound($value);
+        $value =~ s/-//g;
+      }
+      else {
+        my ($pkg, $file, $line) = caller;
+        my $class = ref $self;
+        ERROR("$class->type($type, undef) called from $pkg ($file line $line)");
+      }
+    }
+    elsif ($type eq 'email') {
+      $type = 'string';
+      if (Bugzilla->params->{'webservice_email_filter'}) {
+        $value = email_filter($value);
+      }
+    }
+    return XMLRPC::Data->type($type)->value($value);
+  };
+
+  # Add support for ETags into XMLRPC WebServices
+  *Bugzilla::WebService::bz_etag = sub {
+    return Bugzilla::WebService::Server->bz_etag($_[1]);
+  };
 }
 
 sub initialize {
-    my $self = shift;
-    my %retval = $self->SUPER::initialize(@_);
-    $retval{'serializer'}   = Bugzilla::XMLRPC::Serializer->new;
-    $retval{'deserializer'} = Bugzilla::XMLRPC::Deserializer->new;
-    $retval{'dispatch_with'} = WS_DISPATCH;
-    return %retval;
+  my $self   = shift;
+  my %retval = $self->SUPER::initialize(@_);
+  $retval{'serializer'}    = Bugzilla::XMLRPC::Serializer->new;
+  $retval{'deserializer'}  = Bugzilla::XMLRPC::Deserializer->new;
+  $retval{'dispatch_with'} = WS_DISPATCH;
+  return %retval;
 }
 
 sub make_response {
-    my $self = shift;
-    my $cgi = Bugzilla->cgi;
-
-    $self->SUPER::make_response(@_);
-
-    # XMLRPC::Transport::HTTP::CGI doesn't know about Bugzilla carrying around
-    # its cookies in Bugzilla::CGI, so we need to copy them over.
-    foreach my $cookie (@{$cgi->{'Bugzilla_cookie_list'}}) {
-        $self->response->headers->push_header('Set-Cookie', $cookie);
-    }
-
-    # Copy across security related headers from Bugzilla::CGI
-    foreach my $header (split(/[\r\n]+/, $cgi->header)) {
-        my ($name, $value) = $header =~ /^([^:]+): (.*)/;
-        if (!$self->response->headers->header($name)) {
-           $self->response->headers->header($name => $value);
-        }
-    }
-
-    # ETag support
-    my $etag = $self->bz_etag;
-    if (!$etag) {
-        my $data = $self->response->as_string;
-        $etag = $self->bz_etag($data);
-    }
-
-    if ($etag && $cgi->check_etag($etag)) {
-        $self->response->headers->push_header('ETag', $etag);
-        $self->response->headers->push_header('status', '304 Not Modified');
-    }
-    elsif ($etag) {
-        $self->response->headers->push_header('ETag', $etag);
+  my $self = shift;
+  my $cgi  = Bugzilla->cgi;
+
+  $self->SUPER::make_response(@_);
+
+  # XMLRPC::Transport::HTTP::CGI doesn't know about Bugzilla carrying around
+  # its cookies in Bugzilla::CGI, so we need to copy them over.
+  foreach my $cookie (@{$cgi->{'Bugzilla_cookie_list'}}) {
+    $self->response->headers->push_header('Set-Cookie', $cookie);
+  }
+
+  # Copy across security related headers from Bugzilla::CGI
+  foreach my $header (split(/[\r\n]+/, $cgi->header)) {
+    my ($name, $value) = $header =~ /^([^:]+): (.*)/;
+    if (!$self->response->headers->header($name)) {
+      $self->response->headers->header($name => $value);
     }
+  }
+
+  # ETag support
+  my $etag = $self->bz_etag;
+  if (!$etag) {
+    my $data = $self->response->as_string;
+    $etag = $self->bz_etag($data);
+  }
+
+  if ($etag && $cgi->check_etag($etag)) {
+    $self->response->headers->push_header('ETag',   $etag);
+    $self->response->headers->push_header('status', '304 Not Modified');
+  }
+  elsif ($etag) {
+    $self->response->headers->push_header('ETag', $etag);
+  }
 }
 
 sub handle_login {
-    my ($self, $classes, $action, $uri, $method) = @_;
-    my $class = $classes->{$uri};
-    if (!$class) {
-        ThrowCodeError('unknown_method', { method => $method eq 'methodName' ? '' : '.' . $method });
-    }
-    my $full_method = $uri . "." . $method;
-    # Only allowed methods to be used from the module's whitelist
-    my $file = $class;
-    $file =~ s{::}{/}g;
-    $file .= ".pm";
-    require $file;
-    if (none { $_ eq $method } $class->PUBLIC_METHODS) {
-        ThrowCodeError('unknown_method', { method => $full_method });
-    }
-    $self->SUPER::handle_login($class, $method, $full_method);
-    return;
+  my ($self, $classes, $action, $uri, $method) = @_;
+  my $class = $classes->{$uri};
+  if (!$class) {
+    ThrowCodeError('unknown_method',
+      {method => $method eq 'methodName' ? '' : '.' . $method});
+  }
+  my $full_method = $uri . "." . $method;
+
+  # Only allowed methods to be used from the module's whitelist
+  my $file = $class;
+  $file =~ s{::}{/}g;
+  $file .= ".pm";
+  require $file;
+  if (none { $_ eq $method } $class->PUBLIC_METHODS) {
+    ThrowCodeError('unknown_method', {method => $full_method});
+  }
+  $self->SUPER::handle_login($class, $method, $full_method);
+  return;
 }
 
 1;
@@ -124,6 +127,7 @@ sub handle_login {
 # and also, in some cases, to more-usefully decode them.
 package Bugzilla::XMLRPC::Deserializer;
 use strict;
+
 # We can't use "use base" because XMLRPC::Serializer doesn't return
 # a true value.
 use XMLRPC::Lite;
@@ -135,100 +139,111 @@ use Bugzilla::WebService::Util qw(fix_credentials);
 use Scalar::Util qw(tainted);
 
 sub new {
-    my $self = shift->SUPER::new(@_);
-    # Initialise XML::Parser to not expand references to entities, to prevent DoS
-    require XML::Parser;
-    my $parser = XML::Parser->new( NoExpand => 1, Handlers => { Default => sub {} } );
-    $self->{_parser}->parser($parser, $parser);
-    return $self;
+  my $self = shift->SUPER::new(@_);
+
+  # Initialise XML::Parser to not expand references to entities, to prevent DoS
+  require XML::Parser;
+  my $parser = XML::Parser->new(
+    NoExpand => 1,
+    Handlers => {
+      Default => sub { }
+    }
+  );
+  $self->{_parser}->parser($parser, $parser);
+  return $self;
 }
 
 sub deserialize {
-    my $self = shift;
-
-    # Only allow certain content types to protect against CSRF attacks
-    my $content_type = lc($ENV{'CONTENT_TYPE'});
-    # Remove charset, etc, if provided
-    $content_type =~ s/^([^;]+);.*/$1/;
-    if (!grep($_ eq $content_type, XMLRPC_CONTENT_TYPE_WHITELIST)) {
-        ThrowUserError('xmlrpc_illegal_content_type',
-                       { content_type => $ENV{'CONTENT_TYPE'} });
-    }
+  my $self = shift;
 
-    my ($xml) = @_;
-    my $som = $self->SUPER::deserialize(@_);
-    if (tainted($xml)) {
-        $som->{_bz_do_taint} = 1;
-    }
-    bless $som, 'Bugzilla::XMLRPC::SOM';
-    my $params = $som->paramsin;
-    # This allows positional parameters for Testopia.
-    $params = {} if ref $params ne 'HASH';
+  # Only allow certain content types to protect against CSRF attacks
+  my $content_type = lc($ENV{'CONTENT_TYPE'});
+
+  # Remove charset, etc, if provided
+  $content_type =~ s/^([^;]+);.*/$1/;
+  if (!grep($_ eq $content_type, XMLRPC_CONTENT_TYPE_WHITELIST)) {
+    ThrowUserError('xmlrpc_illegal_content_type',
+      {content_type => $ENV{'CONTENT_TYPE'}});
+  }
+
+  my ($xml) = @_;
+  my $som = $self->SUPER::deserialize(@_);
+  if (tainted($xml)) {
+    $som->{_bz_do_taint} = 1;
+  }
+  bless $som, 'Bugzilla::XMLRPC::SOM';
+  my $params = $som->paramsin;
+
+  # This allows positional parameters for Testopia.
+  $params = {} if ref $params ne 'HASH';
 
-    # Update the params to allow for several convenience key/values
-    # use for authentication
-    fix_credentials($params);
+  # Update the params to allow for several convenience key/values
+  # use for authentication
+  fix_credentials($params);
 
-    Bugzilla->input_params($params);
+  Bugzilla->input_params($params);
 
-    return $som;
+  return $som;
 }
 
 # Some method arguments need to be converted in some way, when they are input.
 sub decode_value {
-    my $self = shift;
-    my ($type) = @{ $_[0] };
-    my $value = $self->SUPER::decode_value(@_);
-
-    # We only validate/convert certain types here.
-    return $value if $type !~ /^(?:int|i4|boolean|double|dateTime\.iso8601)$/;
-
-    # Though the XML-RPC standard doesn't allow an empty <int>,
-    # <double>,or <dateTime.iso8601>,  we do, and we just say
-    # "that's undef".
-    if (grep($type eq $_, qw(int double dateTime))) {
-        return undef if $value eq '';
-    }
-
-    my $validator = $self->_validation_subs->{$type};
-    if (!$validator->($value)) {
-        ThrowUserError('xmlrpc_invalid_value',
-                       { type => $type, value => $value });
-    }
-
-    # We convert dateTimes to a DB-friendly date format.
-    if ($type eq 'dateTime.iso8601') {
-        if ($value !~ /T.*[\-+Z]/i) {
-           # The caller did not specify a timezone, so we assume UTC.
-           # pass 'Z' specifier to datetime_from to force it
-           $value = $value . 'Z';
-        }
-        $value = Bugzilla::WebService::Server::XMLRPC->datetime_format_inbound($value);
+  my $self   = shift;
+  my ($type) = @{$_[0]};
+  my $value  = $self->SUPER::decode_value(@_);
+
+  # We only validate/convert certain types here.
+  return $value if $type !~ /^(?:int|i4|boolean|double|dateTime\.iso8601)$/;
+
+  # Though the XML-RPC standard doesn't allow an empty <int>,
+  # <double>,or <dateTime.iso8601>,  we do, and we just say
+  # "that's undef".
+  if (grep($type eq $_, qw(int double dateTime))) {
+    return undef if $value eq '';
+  }
+
+  my $validator = $self->_validation_subs->{$type};
+  if (!$validator->($value)) {
+    ThrowUserError('xmlrpc_invalid_value', {type => $type, value => $value});
+  }
+
+  # We convert dateTimes to a DB-friendly date format.
+  if ($type eq 'dateTime.iso8601') {
+    if ($value !~ /T.*[\-+Z]/i) {
+
+      # The caller did not specify a timezone, so we assume UTC.
+      # pass 'Z' specifier to datetime_from to force it
+      $value = $value . 'Z';
     }
+    $value = Bugzilla::WebService::Server::XMLRPC->datetime_format_inbound($value);
+  }
 
-    return $value;
+  return $value;
 }
 
 sub _validation_subs {
-    my $self = shift;
-    return $self->{_validation_subs} if $self->{_validation_subs};
-    # The only place that XMLRPC::Lite stores any sort of validation
-    # regex is in XMLRPC::Serializer. We want to re-use those regexes here.
-    my $lookup = Bugzilla::XMLRPC::Serializer->new->typelookup;
-
-    # $lookup is a hash whose values are arrayrefs, and whose keys are the
-    # names of types. The second item of each arrayref is a subroutine
-    # that will do our validation for us.
-    my %validators = map { $_ => $lookup->{$_}->[1] } (keys %$lookup);
-    # Add a boolean validator
-    $validators{'boolean'} = sub {$_[0] =~ /^[01]$/};
-    # Some types have multiple names, or have a different name in
-    # XMLRPC::Serializer than their standard XML-RPC name.
-    $validators{'dateTime.iso8601'} = $validators{'dateTime'};
-    $validators{'i4'} = $validators{'int'};
-
-    $self->{_validation_subs} = \%validators;
-    return \%validators;
+  my $self = shift;
+  return $self->{_validation_subs} if $self->{_validation_subs};
+
+  # The only place that XMLRPC::Lite stores any sort of validation
+  # regex is in XMLRPC::Serializer. We want to re-use those regexes here.
+  my $lookup = Bugzilla::XMLRPC::Serializer->new->typelookup;
+
+  # $lookup is a hash whose values are arrayrefs, and whose keys are the
+  # names of types. The second item of each arrayref is a subroutine
+  # that will do our validation for us.
+  my %validators = map { $_ => $lookup->{$_}->[1] } (keys %$lookup);
+
+  # Add a boolean validator
+  $validators{'boolean'} = sub { $_[0] =~ /^[01]$/ };
+
+  # Some types have multiple names, or have a different name in
+  # XMLRPC::Serializer than their standard XML-RPC name.
+  $validators{'dateTime.iso8601'} = $validators{'dateTime'};
+  $validators{'i4'}               = $validators{'int'};
+
+  $self->{_validation_subs} = \%validators;
+  return \%validators;
 }
 
 1;
@@ -240,16 +255,16 @@ our @ISA = qw(XMLRPC::SOM);
 use Bugzilla::WebService::Util qw(taint_data);
 
 sub paramsin {
-    my $self = shift;
-    if (!$self->{bz_params_in}) {
-        my @params = $self->SUPER::paramsin(@_);
-        if ($self->{_bz_do_taint}) {
-            taint_data(@params);
-        }
-        $self->{bz_params_in} = \@params;
+  my $self = shift;
+  if (!$self->{bz_params_in}) {
+    my @params = $self->SUPER::paramsin(@_);
+    if ($self->{_bz_do_taint}) {
+      taint_data(@params);
     }
-    my $params = $self->{bz_params_in};
-    return wantarray ? @$params : $params->[0];
+    $self->{bz_params_in} = \@params;
+  }
+  my $params = $self->{bz_params_in};
+  return wantarray ? @$params : $params->[0];
 }
 
 1;
@@ -259,43 +274,46 @@ sub paramsin {
 package Bugzilla::XMLRPC::Serializer;
 use Scalar::Util qw(blessed);
 use strict;
+
 # We can't use "use base" because XMLRPC::Serializer doesn't return
 # a true value.
 use XMLRPC::Lite;
 our @ISA = qw(XMLRPC::Serializer);
 
 sub new {
-    my $class = shift;
-    my $self = $class->SUPER::new(@_);
-    # This fixes UTF-8.
-    $self->{'_typelookup'}->{'base64'} =
-        [10, sub { !utf8::is_utf8($_[0]) && $_[0] =~ /[^\x09\x0a\x0d\x20-\x7f]/},
-        'as_base64'];
-    # This makes arrays work right even though we're a subclass.
-    # (See http://rt.cpan.org//Ticket/Display.html?id=34514)
-    $self->{'_encodingStyle'} = '';
-    return $self;
+  my $class = shift;
+  my $self  = $class->SUPER::new(@_);
+
+  # This fixes UTF-8.
+  $self->{'_typelookup'}->{'base64'} = [
+    10, sub { !utf8::is_utf8($_[0]) && $_[0] =~ /[^\x09\x0a\x0d\x20-\x7f]/ },
+    'as_base64'
+  ];
+
+  # This makes arrays work right even though we're a subclass.
+  # (See http://rt.cpan.org//Ticket/Display.html?id=34514)
+  $self->{'_encodingStyle'} = '';
+  return $self;
 }
 
 # Here the XMLRPC::Serializer is extended to use the XMLRPC nil extension.
 sub encode_object {
-    my $self = shift;
-    my @encoded = $self->SUPER::encode_object(@_);
+  my $self    = shift;
+  my @encoded = $self->SUPER::encode_object(@_);
 
-    return $encoded[0]->[0] eq 'nil'
-        ? ['value', {}, [@encoded]]
-        : @encoded;
+  return $encoded[0]->[0] eq 'nil' ? ['value', {}, [@encoded]] : @encoded;
 }
 
 # Removes undefined values so they do not produce invalid XMLRPC.
 sub envelope {
-    my $self = shift;
-    my ($type, $method, $data) = @_;
-    # If the type isn't a successful response we don't want to change the values.
-    if ($type eq 'response'){
-        $data = _strip_undefs($data);
-    }
-    return $self->SUPER::envelope($type, $method, $data);
+  my $self = shift;
+  my ($type, $method, $data) = @_;
+
+  # If the type isn't a successful response we don't want to change the values.
+  if ($type eq 'response') {
+    $data = _strip_undefs($data);
+  }
+  return $self->SUPER::envelope($type, $method, $data);
 }
 
 # In an XMLRPC response we have to handle hashes of arrays, hashes, scalars,
@@ -303,57 +321,57 @@ sub envelope {
 # The whole XMLRPC::Data object must be removed if its value key is undefined
 # so it cannot be recursed like the other hash type objects.
 sub _strip_undefs {
-    my ($initial) = @_;
-    if (ref $initial eq "HASH" || (blessed $initial && $initial->isa("HASH"))) {
-        while (my ($key, $value) = each(%$initial)) {
-            if ( !defined $value
-                 || (blessed $value && $value->isa('XMLRPC::Data') && !defined $value->value) )
-            {
-                # If the value is undefined remove it from the hash.
-                delete $initial->{$key};
-            }
-            else {
-                $initial->{$key} = _strip_undefs($value);
-            }
-        }
+  my ($initial) = @_;
+  if (ref $initial eq "HASH" || (blessed $initial && $initial->isa("HASH"))) {
+    while (my ($key, $value) = each(%$initial)) {
+      if (!defined $value
+        || (blessed $value && $value->isa('XMLRPC::Data') && !defined $value->value))
+      {
+        # If the value is undefined remove it from the hash.
+        delete $initial->{$key};
+      }
+      else {
+        $initial->{$key} = _strip_undefs($value);
+      }
     }
-    if (ref $initial eq "ARRAY" || (blessed $initial && $initial->isa("ARRAY"))) {
-        for (my $count = 0; $count < scalar @{$initial}; $count++) {
-            my $value = $initial->[$count];
-            if ( !defined $value
-                 || (blessed $value && $value->isa('XMLRPC::Data') && !defined $value->value) )
-            {
-                # If the value is undefined remove it from the array.
-                splice(@$initial, $count, 1);
-                $count--;
-            }
-            else {
-                $initial->[$count] = _strip_undefs($value);
-            }
-        }
+  }
+  if (ref $initial eq "ARRAY" || (blessed $initial && $initial->isa("ARRAY"))) {
+    for (my $count = 0; $count < scalar @{$initial}; $count++) {
+      my $value = $initial->[$count];
+      if (!defined $value
+        || (blessed $value && $value->isa('XMLRPC::Data') && !defined $value->value))
+      {
+        # If the value is undefined remove it from the array.
+        splice(@$initial, $count, 1);
+        $count--;
+      }
+      else {
+        $initial->[$count] = _strip_undefs($value);
+      }
     }
-    return $initial;
+  }
+  return $initial;
 }
 
 sub BEGIN {
-    no strict 'refs';
-    for my $type (qw(double i4 int dateTime)) {
-        my $method = 'as_' . $type;
-        *$method = sub {
-            my ($self, $value) = @_;
-            if (!defined($value)) {
-                return as_nil();
-            }
-            else {
-                my $super_method = "SUPER::$method";
-                return $self->$super_method($value);
-            }
-        }
-    }
+  no strict 'refs';
+  for my $type (qw(double i4 int dateTime)) {
+    my $method = 'as_' . $type;
+    *$method = sub {
+      my ($self, $value) = @_;
+      if (!defined($value)) {
+        return as_nil();
+      }
+      else {
+        my $super_method = "SUPER::$method";
+        return $self->$super_method($value);
+      }
+      }
+  }
 }
 
 sub as_nil {
-    return ['nil', {}];
+  return ['nil', {}];
 }
 
 1;