submitter_id
);
-use constant REQUIRED_FIELD_MAP => {bug_id => 'bug',};
+use constant REQUIRED_FIELD_MAP => {bug_id => 'bug',};
use constant EXTRA_REQUIRED_FIELDS => qw(data);
use constant UPDATE_COLUMNS => qw(
my $dbh = Bugzilla->dbh;
my $username = $login_data->{username};
- my $user = new Bugzilla::User({name => $username});
+ my $user = new Bugzilla::User({name => $username});
return {failure => AUTH_NO_SUCH_USER} unless $user;
my @custom
= grep { $_->type != FIELD_TYPE_MULTI_SELECT } Bugzilla->active_custom_fields;
my @custom_names = map { $_->name } @custom;
- my @columns = qw(
+ my @columns = qw(
assigned_to
bug_file_loc
bug_severity
# make it the "name" param.
if ( !defined $param
|| (!ref($param) && $param !~ /^[0-9]+$/)
- || (ref($param) && $param->{id} !~ /^[0-9]+$/))
+ || (ref($param) && $param->{id} !~ /^[0-9]+$/))
{
if ($param) {
- my $alias = ref($param) ? $param->{id} : $param;
+ my $alias = ref($param) ? $param->{id} : $param;
my $bug_id = bug_alias_to_id($alias);
if (!$bug_id) {
my $error_self = {};
sub object_cache_key {
my $class = shift;
- my $key = $class->SUPER::object_cache_key(@_) || return;
+ my $key = $class->SUPER::object_cache_key(@_) || return;
return $key . ',' . Bugzilla->user->id;
}
# so include them in the list if they have been specified.
if (exists $params->{"${field}_id"}) {
my $current_ids = $params->{"${field}_id"};
- my @id_array = ref $current_ids ? @$current_ids : ($current_ids);
+ my @id_array = ref $current_ids ? @$current_ids : ($current_ids);
push(@ids, @id_array);
}
push @bug_ids, $comment->extra_data;
next;
}
- my $s = $comment->already_wrapped ? qr/\s/ : qr/\h/;
+ my $s = $comment->already_wrapped ? qr/\s/ : qr/\h/;
my $text = $comment->body;
# Full bug links
if ($see_also) {
my $see_also_array = $see_also;
if (!ref $see_also_array) {
- $see_also = trim($see_also);
+ $see_also = trim($see_also);
$see_also_array = [split(/[\s,]+/, $see_also)];
}
foreach my $value (@$see_also_array) {
my $keyword_array = $keywords_in;
if (!ref $keyword_array) {
- $keywords_in = trim($keywords_in);
+ $keywords_in = trim($keywords_in);
$keyword_array = [split(/[\s,]+/, $keywords_in)];
}
my $id;
if ($qa_contact) {
$qa_contact = Bugzilla::User->check($qa_contact) if !ref $qa_contact;
- $id = $qa_contact->id;
+ $id = $qa_contact->id;
# create() checks this another way, so we don't have to run this
# check during create().
&& scalar @$dependson
)
{
- my $dep_bugs = Bugzilla::Bug->new_from_list($dependson);
+ my $dep_bugs = Bugzilla::Bug->new_from_list($dependson);
my $count_open = grep { $_->isopened } @$dep_bugs;
if ($count_open) {
my $bug_id = ref($invocant) ? $invocant->id : undef;
my ($self, $dependson, $blocked) = @_;
my %extra = (blocked => $blocked);
$dependson = $self->_check_dependencies($dependson, 'dependson', \%extra);
- $blocked = $extra{blocked};
+ $blocked = $extra{blocked};
# These may already be detainted, but all setters are supposed to
# detaint their input if they've run a validator (just as though
$params ||= {};
# Fill out info that doesn't change and callers may not pass in
- $params->{'bug_id'} = $self;
+ $params->{'bug_id'} = $self;
$params->{'thetext'} = defined($comment) ? $comment : '';
# Validate all the entered data
# So we have to store and pass the name as entered by the user to
# the error message, if we have it.
my $group_name = blessed($group) ? $group->name : $group;
- my $args = {
+ my $args = {
name => $group_name,
product => $self->product,
bug_id => $self->id,
# See add_group() for the reason why we store the user input.
my $group_name = blessed($group) ? $group->name : $group;
- my $args = {
+ my $args = {
name => $group_name,
product => $self->product,
bug_id => $self->id,
if (length($removestr) > MAX_LINE_LENGTH) {
my $commaposition = find_wrap_point($removed, MAX_LINE_LENGTH);
$removestr = substr($removed, 0, $commaposition);
- $removed = substr($removed, $commaposition);
+ $removed = substr($removed, $commaposition);
}
else {
$removed = ""; # no more entries
if (length($addstr) > MAX_LINE_LENGTH) {
my $commaposition = find_wrap_point($added, MAX_LINE_LENGTH);
$addstr = substr($added, 0, $commaposition);
- $added = substr($added, $commaposition);
+ $added = substr($added, $commaposition);
}
else {
$added = ""; # no more entries
@{$deps{$target}} = @{$deptree{$target}};
my @stack = @{$deps{$target}};
while (@stack) {
- my $i = shift @stack;
+ my $i = shift @stack;
my $dep_list = $dbh->selectcol_arrayref($sth{$target}, undef, $i);
foreach my $t (@$dep_list) {
# Bugzilla::User objects of people in various roles. More than one person
# can 'have' a role, if the person in that role has changed, or people are
# watching.
- my @assignees = ($bug->assigned_to);
+ my @assignees = ($bug->assigned_to);
my @qa_contacts = $bug->qa_contact || ();
my @ccs = @{$bug->cc_users};
# the same objects are used for each recipient, so cache the flattened hash
my $cache = Bugzilla->request_cache->{bugmail_flat_objects} ||= {};
- my $key = blessed($object) . '-' . $object->id;
+ my $key = blessed($object) . '-' . $object->id;
return $cache->{$key} ||= $object->flatten_to_hash;
}
&& $diff->{field_name} eq $changes[-1]->{field_name}
&& $diff->{bug_when} eq $changes[-1]->{bug_when}
&& $diff->{who} eq $changes[-1]->{who}
- && ($diff->{attach_id} // 0) == ($changes[-1]->{attach_id} // 0)
+ && ($diff->{attach_id} // 0) == ($changes[-1]->{attach_id} // 0)
&& ($diff->{comment_id} // 0) == ($changes[-1]->{comment_id} // 0))
{
my $old_change = pop @changes;
}
sub _get_new_bugmail_fields {
- my $bug = shift;
+ my $bug = shift;
my @fields = @{Bugzilla->fields({obsolete => 0, in_new_bugmail => 1})};
my @diffs;
my $params = Bugzilla->params;
if (ref $param) {
my $bug_id = $param->{bug_id};
- my $name = $param->{name} || $param->{value};
+ my $name = $param->{name} || $param->{value};
if (!defined $bug_id) {
ThrowCodeError('bad_arg', {argument => 'bug_id', function => "${class}::new"});
}
}
my $condition = 'bug_id = ? AND value = ?';
- my @values = ($bug_id, $name);
+ my @values = ($bug_id, $name);
$param = {condition => $condition, values => \@values};
}
# We don't precompile any functions here, that's done specially in
# mod_perl code.
- $invocant->_setup_symbols(
- qw(:no_xhtml :oldstyle_urls :private_tempfiles
- :unique_headers)
- );
+ $invocant->_setup_symbols(qw(:no_xhtml :oldstyle_urls :private_tempfiles
+ :unique_headers));
}
BEGIN { __PACKAGE__->_init_bz_cgi_globals() if i_am_cgi(); }
my $is_safe_content_type = $content_type =~ $safe_content_type_re;
# Safe referers are ones that begin with the urlbase.
- my $referer = $self->referer;
+ my $referer = $self->referer;
my $is_safe_referer = $referer && $referer =~ $safe_referer_re;
if (!$is_safe_referer && !$is_safe_content_type) {
sub new {
my $invocant = shift;
- my $class = ref($invocant) || $invocant;
+ my $class = ref($invocant) || $invocant;
# Create a ref to an empty hash and bless it
my $self = {};
my $sth = $dbh->prepare($query);
- my $gt_index = $self->{'gt'} ? scalar(@{$self->{'lines'}}) : undef;
+ my $gt_index = $self->{'gt'} ? scalar(@{$self->{'lines'}}) : undef;
my $line_index = 0;
$maxvals[$gt_index] = 0 if $gt_index;
my ($self, $tag) = @_;
$tag = $self->_check_tag($tag);
- my $tags = $self->tags;
+ my $tags = $self->tags;
my $index = first { lc($tags->[$_]) eq lc($tag) } 0 .. scalar(@$tags) - 1;
return unless defined $index;
splice(@$tags, $index, 1);
}
my $condition = 'product_id = ? AND name = ?';
- my @values = ($product->id, $name);
+ my @values = ($product->id, $name);
$param = {condition => $condition, values => \@values};
}
my $proto = getprotobyname('tcp');
socket(SOCK, PF_INET, SOCK_STREAM, $proto);
my $iaddr = inet_aton($host) || return "The host $host cannot be resolved";
- my $sin = sockaddr_in($port, $iaddr);
+ my $sin = sockaddr_in($port, $iaddr);
if (!connect(SOCK, $sin)) {
return "Failed to connect to $host:$port ($!); unable to enable SSL";
}
sub check_ip {
my $inbound_proxies = shift;
- my @proxies = split(/[\s,]+/, $inbound_proxies);
+ my @proxies = split(/[\s,]+/, $inbound_proxies);
foreach my $proxy (@proxies) {
validate_ip($proxy) || return "$proxy is not a valid IPv4 or IPv6 address";
}
}
sub check_bug_status {
- my $bug_status = shift;
+ my $bug_status = shift;
my @closed_bug_statuses = map { $_->name } closed_bug_statuses();
if (!grep($_ eq $bug_status, @closed_bug_statuses)) {
return "Must be a valid closed status: one of "
my $sql_vers = $self->bz_server_version;
$self->disconnect;
- my $sql_want = $db->{db_version};
+ my $sql_want = $db->{db_version};
my $version_ok = vers_cmp($sql_vers, $sql_want) > -1 ? 1 : 0;
my $sql_server = $db->{name};
# See if we can connect to the actual Bugzilla database.
my $conn_success = eval { $dbh = connect_main() };
- my $db_name = Bugzilla->localconfig->{db_name};
+ my $db_name = Bugzilla->localconfig->{db_name};
if (!$conn_success) {
$dbh = _get_no_db_connection();
my ($self) = @_;
return $self->{private_bz_schema} if exists $self->{private_bz_schema};
my @module_parts = split('::', ref $self);
- my $module_name = pop @module_parts;
+ my $module_name = pop @module_parts;
$self->{private_bz_schema} = Bugzilla::DB::Schema->new($module_name);
return $self->{private_bz_schema};
}
my $insert
= $self->prepare("INSERT INTO $sql_table (value,sortkey) VALUES (?,?)");
my $sortorder = 0;
- my $maxlen = max(map(length($_), @$valuelist)) + 2;
+ my $maxlen = max(map(length($_), @$valuelist)) + 2;
foreach my $value (@$valuelist) {
$sortorder += 100;
$insert->execute($value, $sortorder);
$i++;
}
- my $first_row = sprintf($format_string, @$columns);
+ my $first_row = sprintf($format_string, @$columns);
my @explain_rows = ($first_row, '-' x length($first_row));
while (my $row = $sth->fetchrow_arrayref) {
my @fixed = map { defined $_ ? $_ : 'NULL' } @$row;
# This parameter is not yet defined when the DB is being built for
# the very first time. The code below still works properly, however,
# because the default maxattachmentsize is smaller than $min_max_allowed.
- my $max_attachment = (Bugzilla->params->{'maxattachmentsize'} || 0) * 1024;
+ my $max_attachment = (Bugzilla->params->{'maxattachmentsize'} || 0) * 1024;
my $needed_max_allowed = max($min_max_allowed, $max_attachment);
if ($current_max_allowed < $needed_max_allowed) {
warn install_string('max_allowed_packet',
my ($binary, $utf8) = ($sql_def, $sql_def);
my $type = $self->_bz_schema->convert_type($col_info->{TYPE});
$binary =~ s/(\Q$type\E)/$1 CHARACTER SET binary/;
- $utf8 =~ s/(\Q$type\E)/$1 CHARACTER SET utf8/;
+ $utf8 =~ s/(\Q$type\E)/$1 CHARACTER SET utf8/;
push(@binary_sql, "MODIFY COLUMN $name $binary");
push(@utf8_sql, "MODIFY COLUMN $name $utf8");
}
# looks like. So we remove defaults from columns that aren't supposed
# to have them
sub _fix_defaults {
- my $self = shift;
+ my $self = shift;
my $maj_version = substr($self->bz_server_version, 0, 1);
return if $maj_version < 5;
# The oldest column that could have this problem is bugs.assigned_to,
# so if it doesn't have the problem, we just skip doing this entirely.
- my $assi_def = $self->_bz_raw_column_info('bugs', 'assigned_to');
+ my $assi_def = $self->_bz_raw_column_info('bugs', 'assigned_to');
my $assi_default = $assi_def->{COLUMN_DEF};
# This "ne ''" thing is necessary because _raw_column_info seems to
# Get the exact default from the database without any
# "fixing" by bz_column_info_real.
- my $raw_info = $self->_bz_raw_column_info($table, $column);
+ my $raw_info = $self->_bz_raw_column_info($table, $column);
my $raw_default = $raw_info->{COLUMN_DEF};
if (defined $raw_default) {
if ($raw_default eq '') {
print "Fixing defaults...\n";
foreach my $table (reverse sort keys %fix_columns) {
my @alters = map("ALTER COLUMN $_ DROP DEFAULT", @{$fix_columns{$table}});
- my $sql = "ALTER TABLE $table " . join(',', @alters);
+ my $sql = "ALTER TABLE $table " . join(',', @alters);
$self->do($sql);
}
}
# Oracle requires a FROM clause in all SELECT statements, so append
# "FROM dual" to queries without one (e.g., "SELECT NOW()")
my $is_select = ($part =~ m/^\s*SELECT\b/io);
- my $has_from = ($part =~ m/\bFROM\b/io) if $is_select;
+ my $has_from = ($part =~ m/\bFROM\b/io) if $is_select;
# Oracle includes the time in CURRENT_DATE.
$part =~ s/\bCURRENT_DATE\b/TRUNC(CURRENT_DATE)/io;
# triggers ourselves.
if ($def->{TYPE} =~ /SERIAL/i) {
my $sequence = "${table}_${column}_SEQ";
- my $exists = $self->selectrow_array($sth, undef, $sequence);
+ my $exists = $self->selectrow_array($sth, undef, $sequence);
if (!$exists) {
my @sql = $self->_get_create_seq_ddl($table, $column);
$self->do($_) foreach @sql;
$to_table = 'tag';
}
if ($update =~ /CASCADE/i) {
- my $trigger_name = uc($fk_name . "_UC");
+ my $trigger_name = uc($fk_name . "_UC");
my $exist_trigger = $self->selectcol_arrayref($sth, undef, $trigger_name);
if (@$exist_trigger) {
$self->do("DROP TRIGGER $trigger_name");
}
# Drop the trigger which causes bug 541553
- my $trigger_name = "PRODUCTS_MILESTONEURL";
+ my $trigger_name = "PRODUCTS_MILESTONEURL";
my $exist_trigger = $self->selectcol_arrayref($sth, undef, $trigger_name);
if (@$exist_trigger) {
$self->do("DROP TRIGGER $trigger_name");
my ($self, $table, $column_fks) = @_;
my @ddl;
foreach my $column (keys %$column_fks) {
- my $def = $column_fks->{$column};
+ my $def = $column_fks->{$column};
my $fk_string = $self->get_fk_ddl($table, $column, $def);
push(@ddl, $fk_string);
}
sub get_table_indexes_abstract {
my ($self, $table) = @_;
my $table_def = $self->get_table_abstract($table);
- my %indexes = @{$table_def->{INDEXES} || []};
+ my %indexes = @{$table_def->{INDEXES} || []};
return \%indexes;
}
my $finfo = shift(@fields);
push(@col_lines, "\t$field\t" . $self->get_type_ddl($finfo));
if ($self->FK_ON_CREATE and $finfo->{REFERENCES}) {
- my $fk = $finfo->{REFERENCES};
+ my $fk = $finfo->{REFERENCES};
my $fk_ddl = $self->get_fk_ddl($table, $field, $fk);
push(@fk_lines, $fk_ddl);
}
my ($table, $column, $new_def, $set_nulls_to) = @_;
my @statements;
- my $old_def = $self->get_column_abstract($table, $column);
+ my $old_def = $self->get_column_abstract($table, $column);
my $specific = $self->{db_specific};
# If the types have changed, we have to deal with that.
my ($self, $table, $column) = @_;
my $abstract_fields = $self->{abstract_schema}{$table}{FIELDS};
- my $name_position = firstidx { $_ eq $column } @$abstract_fields;
+ my $name_position = firstidx { $_ eq $column } @$abstract_fields;
die "Attempted to delete nonexistent column ${table}.${column}"
if $name_position == -1;
sub delete_index {
my ($self, $table, $name) = @_;
- my $indexes = $self->{abstract_schema}{$table}{INDEXES};
+ my $indexes = $self->{abstract_schema}{$table}{INDEXES};
my $name_position = firstidx { $_ eq $name } @$indexes;
die "Attempted to delete nonexistent index $name on the $table table"
if $name_position == -1;
# MySQL has a simpler ALTER TABLE syntax than ANSI.
sub get_alter_column_ddl {
my ($self, $table, $column, $new_def, $set_nulls_to) = @_;
- my $old_def = $self->get_column($table, $column);
+ my $old_def = $self->get_column($table, $column);
my %new_def_copy = %$new_def;
if ($old_def->{PRIMARYKEY} && $new_def->{PRIMARYKEY}) {
my ($self, $table, $column, $new_def, $set_nulls_to) = @_;
my @statements;
- my $old_def = $self->get_column_abstract($table, $column);
+ my $old_def = $self->get_column_abstract($table, $column);
my $specific = $self->{db_specific};
# If the types have changed, we have to deal with that.
sub get_add_fks_sql {
my ($self, $table, $column_fks) = @_;
my @clauses = $self->_sqlite_table_lines($table);
- my @add = $self->_column_fks_to_ddl($table, $column_fks);
+ my @add = $self->_column_fks_to_ddl($table, $column_fks);
push(@clauses, @add);
return $self->_sqlite_alter_schema($table, \@clauses);
}
# If we created TheSchwartz tables with COLLATE bugzilla (during the
# 4.1.x development series) re-create them without it.
- my @tables = $self->bz_table_list();
+ my @tables = $self->bz_table_list();
my @ts_tables = grep {/^ts_/} @tables;
my $drop_ok;
foreach my $table (@ts_tables) {
# a "require" on Windows, for example.)
return if $file !~ /^Bugzilla/;
- my $lib_dir = __do_call($class, 'lib_dir');
+ my $lib_dir = __do_call($class, 'lib_dir');
my @class_parts = split('::', $class);
my ($vol, $dir, $file_name) = File::Spec->splitpath($file);
my @dir_parts = File::Spec->splitdir($dir);
use constant enabled => 1;
sub lib_dir {
- my $invocant = shift;
+ my $invocant = shift;
my $package_dir = __do_call($invocant, 'package_dir');
# For extensions that are just files in the extensions/ directory,
{TYPE => 'varchar(64)', NOTNULL => 1, DEFAULT => "'---'"}, FIELD_TYPE_TEXTAREA,
{TYPE => 'MEDIUMTEXT', NOTNULL => 1, DEFAULT => "''"}, FIELD_TYPE_DATETIME,
{TYPE => 'DATETIME'}, FIELD_TYPE_DATE, {TYPE => 'DATE'}, FIELD_TYPE_BUG_ID,
- {TYPE => 'INT3'}, FIELD_TYPE_INTEGER,
+ {TYPE => 'INT3'}, FIELD_TYPE_INTEGER,
{TYPE => 'INT4', NOTNULL => 1, DEFAULT => 0},
};
sub type {
my ($class, $field) = @_;
- my $field_obj = blessed $field ? $field : Bugzilla::Field->check($field);
+ my $field_obj = blessed $field ? $field : Bugzilla::Field->check($field);
my $field_name = $field_obj->name;
if (my $package = $class->CLASS_MAP->{$field_name}) {
my ($class, $flag, $timestamp) = @_;
$timestamp ||= Bugzilla->dbh->selectrow_array('SELECT LOCALTIMESTAMP(0)');
- my $params = {};
+ my $params = {};
my @columns = grep { $_ ne 'id' } $class->_get_db_columns;
# Some columns use date formatting so use alias instead
my ($class, $self, $old_self, $timestamp) = @_;
my @old_summaries = $class->snapshot($old_self->flags);
- my %old_flags = map { $_->id => $_ } @{$old_self->flags};
+ my %old_flags = map { $_->id => $_ } @{$old_self->flags};
foreach my $new_flag (@{$self->flags}) {
if (!$new_flag->id) {
}
my @new_summaries = $class->snapshot($self->flags);
- my @changes = $class->update_activity(\@old_summaries, \@new_summaries);
+ my @changes = $class->update_activity(\@old_summaries, \@new_summaries);
Bugzilla::Hook::process(
'flag_end_of_update',
foreach my $flag (@$flags) {
# $bug is undefined when e.g. editing inclusion and exclusion lists.
- my $obj = $flag->attachment || $bug || $flag->bug;
+ my $obj = $flag->attachment || $bug || $flag->bug;
my $is_retargetted = $flag->retarget($obj);
if ($is_retargetted) {
$dbh->do('UPDATE flags SET type_id = ? WHERE id = ?',
my $dbh = Bugzilla->dbh;
# Depending on the criteria, we may have to append additional tables.
- my $tables = [DB_TABLE];
+ my $tables = [DB_TABLE];
my @criteria = sqlify_criteria($criteria, $tables);
$tables = join(' ', @$tables);
$criteria = join(' AND ', @criteria);
my $dbh = Bugzilla->dbh;
# Depending on the criteria, we may have to append additional tables.
- my $tables = [DB_TABLE];
+ my $tables = [DB_TABLE];
my @criteria = sqlify_criteria($criteria, $tables);
$tables = join(' ', @$tables);
$criteria = join(' AND ', @criteria);
my $user = Bugzilla->user;
return if !Bugzilla->params->{'usevisibilitygroups'};
- my $group_id = $self->id;
+ my $group_id = $self->id;
my $is_visible = grep { $_ == $group_id } @{$user->visible_groups_inherited};
if (!$is_visible) {
ThrowUserError('group_not_visible', {group => $self});
}
sub in {
- my $hook_name = shift;
+ my $hook_name = shift;
my $currently_in = Bugzilla->request_cache->{hook_stack}->[-1] || '';
return $hook_name eq $currently_in ? 1 : 0;
}
my ($admin_gid)
= $dbh->selectrow_array("SELECT id FROM groups WHERE name = 'admin'");
if (!$admin_gid) {
- $dbh->do(
- q{INSERT INTO groups (name, description)
+ $dbh->do(q{INSERT INTO groups (name, description)
VALUES ('admin', 'Administrators')}
);
$admin_gid = $dbh->bz_last_key('groups', 'id');
# We also add a new query for "Open", so that migrated products get
# the same set as new products (see editproducts.cgi.)
my @openedstatuses = ("UNCONFIRMED", "NEW", "ASSIGNED", "REOPENED");
- my $query = join("&", map {"bug_status=$_"} @openedstatuses);
+ my $query = join("&", map {"bug_status=$_"} @openedstatuses);
my $series
= new Bugzilla::Series(undef, $product, $all_name, $open_name, undef, 1,
$query_prod . $query, 1);
sub _make_lang_setting_dynamic {
my $dbh = Bugzilla->dbh;
- my $count = $dbh->selectrow_array(
- q{SELECT 1 FROM setting
+ my $count = $dbh->selectrow_array(q{SELECT 1 FROM setting
WHERE name = 'lang'
AND subclass IS NULL}
);
my $text = $comments{$id};
next if $text !~ /^\Q$string\E(\d+)/;
my $attachment_id = $1;
- my @lines = split("\n", $text);
+ my @lines = split("\n", $text);
if ($type == CMT_ATTACHMENT_CREATED) {
# Now we have to remove the text up until we find a line that's
}
sub _fix_decimal_types {
- my $dbh = Bugzilla->dbh;
+ my $dbh = Bugzilla->dbh;
my $type = {TYPE => 'decimal(7,2)', NOTNULL => 1, DEFAULT => '0'};
$dbh->bz_alter_column('bugs', 'estimated_time', $type);
$dbh->bz_alter_column('bugs', 'remaining_time', $type);
sub _fix_series_creator_fk {
my $dbh = Bugzilla->dbh;
- my $fk = $dbh->bz_fk_info('series', 'creator');
+ my $fk = $dbh->bz_fk_info('series', 'creator');
if ($fk and $fk->{DELETE} eq 'SET NULL') {
$fk->{DELETE} = 'CASCADE';
$dbh->bz_alter_fk('series', 'creator', $fk);
indicate_progress({current => ++$current, total => $total, every => 25});
- my $uri = URI->new("buglist.cgi?$query", 'http');
+ my $uri = URI->new("buglist.cgi?$query", 'http');
my $bug_id_list = $uri->query_param_delete('bug_id');
if (!$bug_id_list) {
warn "No bug_id param for tag $name from user $user_id: $query";
sub _on_delete_set_null_for_audit_log_userid {
my $dbh = Bugzilla->dbh;
- my $fk = $dbh->bz_fk_info('audit_log', 'user_id');
+ my $fk = $dbh->bz_fk_info('audit_log', 'user_id');
if ($fk and !defined $fk->{DELETE}) {
$fk->{DELETE} = 'SET NULL';
$dbh->bz_alter_fk('audit_log', 'user_id', $fk);
}
sub _fix_longdescs_indexes {
- my $dbh = Bugzilla->dbh;
+ my $dbh = Bugzilla->dbh;
my $bug_id_idx = $dbh->bz_index_info('longdescs', 'longdescs_bug_id_idx');
if ($bug_id_idx && scalar @{$bug_id_idx->{'FIELDS'}} < 2) {
$dbh->bz_drop_index('longdescs', 'longdescs_bug_id_idx');
sub _fix_flagclusions_indexes {
my $dbh = Bugzilla->dbh;
foreach my $table ('flaginclusions', 'flagexclusions') {
- my $index = $table . '_type_id_idx';
+ my $index = $table . '_type_id_idx';
my $idx_info = $dbh->bz_index_info($table, $index);
if ($idx_info && $idx_info->{'TYPE'} ne 'UNIQUE') {
return unless $dbh->bz_column_info('bugs', 'alias');
# We need to move the aliases from the bugs table to the bugs_aliases table
- $dbh->do(
- q{
+ $dbh->do(q{
INSERT INTO bugs_aliases (bug_id, alias)
SELECT bug_id, alias FROM bugs WHERE alias IS NOT NULL
}
);
my %all_files = (%create_files, %htaccess, %index_html, %files);
- my %all_dirs = (%create_dirs, %non_recurse_dirs);
+ my %all_dirs = (%create_dirs, %non_recurse_dirs);
return {
create_dirs => \%create_dirs,
unless (-e $file) {
print "Creating $file...\n";
my $info = $files{$file};
- my $fh = new IO::File($file, O_WRONLY | O_CREAT, $info->{perms}) || die $!;
+ my $fh = new IO::File($file, O_WRONLY | O_CREAT, $info->{perms}) || die $!;
print $fh $info->{contents} if $info->{contents};
$fh->close;
}
# If we don't find any of the above binaries in the normal PATH,
# these are extra places we look.
-use constant APACHE_PATH => [
- qw(
+use constant APACHE_PATH => [qw(
/usr/sbin
/usr/local/sbin
/usr/libexec
/usr/local/libexec
- )
-];
+ )];
# The below two constants are subroutines so that they can implement
# a hook. Other than that they are actually constants.
my ($output) = @_;
print "\n", install_string('checking_modules'), "\n" if $output;
- my $root = ROOT_USER;
+ my $root = ROOT_USER;
my $missing = _check_missing(REQUIRED_MODULES, $output);
print "\n", install_string('checking_dbd'), "\n" if $output;
if (my @missing = @{$check_results->{apache}}) {
print install_string('modules_message_apache');
my $missing_string = join(', ', @missing);
- my $size = TABLE_WIDTH - 7;
+ my $size = TABLE_WIDTH - 7;
printf "* \%-${size}s *\n", $missing_string;
my $spaces = TABLE_WIDTH - 2;
print "*", (' ' x $spaces), "*\n";
sub init_console {
eval { ON_WINDOWS && require Win32::Console::ANSI; };
$ENV{'ANSI_COLORS_DISABLED'} = 1 if ($@ || !-t *STDOUT);
- $SIG{__DIE__} = \&_console_die;
+ $SIG{__DIE__} = \&_console_die;
prevent_windows_dialog_boxes();
set_output_encoding();
}
sub work {
my ($class, $job) = @_;
- my $msg = $job->arg->{msg};
+ my $msg = $job->arg->{msg};
my $success = eval { MessageToMTA($msg, 1); 1; };
if (!$success) {
$job->failed($@);
else {
print "Please edit $dest_file to configure the daemon.\n";
}
- }
+ }
}
sub gd_can_uninstall {
}
system($chkconfig, '--del', $initscript);
print "$initscript disabled.", " To stop it, run: $initd/$initscript stop\n";
- }
+ }
}
return $self->SUPER::gd_can_install(@_);
my $dbh = Bugzilla->dbh;
say get_text('migrate_creating_bugs');
- my $init_statuses = Bugzilla::Status->can_change_to();
+ my $init_statuses = Bugzilla::Status->can_change_to();
my %allowed_statuses = map { lc($_->name) => 1 } @$init_statuses;
# Bypass the question of whether or not we can file UNCONFIRMED
my %product = (name => $name, description => $description);
my @initial_cc = split(',', $cc);
- @initial_cc = @{$self->translate_value('user', \@initial_cc)};
+ @initial_cc = @{$self->translate_value('user', \@initial_cc)};
$assigned_to = $self->translate_value('user', $assigned_to);
my %component = (
name => $self->config('component_name'),
}
my $condition = 'product_id = ? AND value = ?';
- my @values = ($product->id, $name);
+ my @values = ($product->id, $name);
$param = {condition => $condition, values => \@values};
}
sub match {
my ($invocant, $criteria) = @_;
my $class = ref($invocant) || $invocant;
- my $dbh = Bugzilla->dbh;
+ my $dbh = Bugzilla->dbh;
return [$class->get_all] if !$criteria;
Bugzilla->memcached->clear({table => $table, id => $self->id});
Bugzilla->memcached->clear_config() if $self->IS_CONFIG;
}
- $self->_object_cache_remove({id => $self->id});
+ $self->_object_cache_remove({id => $self->id});
$self->_object_cache_remove({name => $self->name}) if $self->name;
if (wantarray) {
Bugzilla->memcached->clear({table => $table, id => $self->id});
Bugzilla->memcached->clear_config() if $self->IS_CONFIG;
}
- $self->_object_cache_remove({id => $self->id});
+ $self->_object_cache_remove({id => $self->id});
$self->_object_cache_remove({name => $self->name}) if $self->name;
undef $self;
}
# We put the object's name in the "added" or "removed" field.
# We do this thing with NAME_FIELD because $self->name returns
# the wrong thing for Bugzilla::User.
- my $name = $self->{$self->NAME_FIELD};
+ my $name = $self->{$self->NAME_FIELD};
my @added_removed = $changes eq AUDIT_CREATE ? (undef, $name) : ($name, undef);
$sth->execute($user_id, $class, $self->id, $changes, @added_removed);
return;
# of products.
sub preload {
my ($products, $preload_flagtypes) = @_;
- my %prods = map { $_->id => $_ } @$products;
+ my %prods = map { $_->id => $_ } @$products;
my @prod_ids = keys %prods;
return unless @prod_ids;
require Bugzilla::Component;
foreach my $field (qw(component version milestone)) {
my $classname = "Bugzilla::" . ucfirst($field);
- my $objects = $classname->match({product_id => \@prod_ids});
+ my $objects = $classname->match({product_id => \@prod_ids});
# Now populate the products with this set of objects.
foreach my $obj (@$objects) {
# We cache flag types to avoid useless calls to get_clusions().
my $cache = Bugzilla->request_cache->{flag_types_per_product} ||= {};
$self->{flag_types} = {};
- my $prod_id = $self->id;
+ my $prod_id = $self->id;
my $flagtypes = Bugzilla::FlagType::match({product_id => $prod_id});
foreach my $type ('bug', 'attachment') {
# fields it needs a little help.
sub COLUMN_JOINS {
my $invocant = shift;
- my $user = blessed($invocant) ? $invocant->_user : Bugzilla->user;
+ my $user = blessed($invocant) ? $invocant->_user : Bugzilla->user;
my $joins = {
actual_time => {
sub REPORT_COLUMNS {
my $invocant = shift;
- my $user = blessed($invocant) ? $invocant->_user : Bugzilla->user;
+ my $user = blessed($invocant) ? $invocant->_user : Bugzilla->user;
my $columns = dclone(blessed($invocant) ? $invocant->COLUMNS : COLUMNS);
# Note that the params argument may be modified by Bugzilla::Search
sub new {
my $invocant = shift;
- my $class = ref($invocant) || $invocant;
+ my $class = ref($invocant) || $invocant;
my $self = {@_};
bless($self, $class);
# do it, because there's no way to know if we were passed a tied hash
# or not.
my $params_in = $self->_params;
- my %params = map { $_ => $params_in->{$_} } keys %$params_in;
+ my %params = map { $_ => $params_in->{$_} } keys %$params_in;
$self->{params} = \%params;
return $self;
my $sql = $self->_sql;
# Do we just want bug IDs to pass to the 2nd query or all the data immediately?
- my $func = $all_in_bugs_table ? 'selectall_arrayref' : 'selectcol_arrayref';
+ my $func = $all_in_bugs_table ? 'selectall_arrayref' : 'selectcol_arrayref';
my $bug_ids = $dbh->$func($sql);
my @extra_data = ({sql => $sql, time => tv_interval($start_time)});
sub boolean_charts_to_custom_search {
my ($self, $cgi_buffer) = @_;
my $boolean_charts = $self->_boolean_charts;
- my @as_params = $boolean_charts ? $boolean_charts->as_params : ();
+ my @as_params = $boolean_charts ? $boolean_charts->as_params : ();
# We need to start our new ids after the last custom search "f" id.
# We can just pick the last id in the array because they are sorted
# numerically.
my $last_id = ($self->_field_ids)[-1];
- my $count = defined($last_id) ? $last_id + 1 : 0;
+ my $count = defined($last_id) ? $last_id + 1 : 0;
foreach my $param_set (@as_params) {
foreach my $name (keys %$param_set) {
my $value = $param_set->{$name};
# The newline and this particular spacing makes the resulting
# SQL a bit more readable for debugging.
- my $where = join("\n AND ", $self->_standard_where);
+ my $where = join("\n AND ", $self->_standard_where);
my $clause_sql = $main_clause->as_string;
$where .= "\n AND " . $clause_sql if $clause_sql;
return $where;
my @param_list = keys %$params;
my @all_field_params = grep {/^field-?\d+/} @param_list;
- my @chart_ids = map { /^field(-?\d+)/; $1 } @all_field_params;
+ my @chart_ids = map { /^field(-?\d+)/; $1 } @all_field_params;
@chart_ids = sort { $a <=> $b } uniq @chart_ids;
my $clause = new Bugzilla::Search::Clause();
my @param_list = keys %$params;
my @field_params = grep {/^f\d+$/} @param_list;
- my @field_ids = map { /(\d+)/; $1 } @field_params;
+ my @field_ids = map { /(\d+)/; $1 } @field_params;
@field_ids = sort { $a <=> $b } @field_ids;
return @field_ids;
}
my ($field, $operator) = @$args{qw(field operator)};
$args->{operator} = $self->_reverse_operator($operator);
- $args->{term} = $self->_multiselect_term($args, 1);
+ $args->{term} = $self->_multiselect_term($args, 1);
}
sub _multiselect_multiple {
}
elsif ($field eq 'longdesc') {
$args->{_extra_where} = " AND isprivate = 0" if !$self->_user->is_insider;
- $args->{full_field} = 'thetext';
+ $args->{full_field} = 'thetext';
return "longdescs";
}
elsif ($field eq 'longdescs.isprivate') {
}
my $sql_operator = ($operator =~ /before/) ? '<=' : '>=';
- my $field_id = $field_object->id;
+ my $field_id = $field_object->id;
# Charts on changed* fields need to be field-specific. Otherwise,
# OR chart rows make no sense if they contain multiple fields.
my ($chart_id, $joins, $field, $operator, $quoted)
= @$args{qw(chart_id joins field operator quoted)};
- my $column = ($operator =~ /from/) ? 'removed' : 'added';
+ my $column = ($operator =~ /from/) ? 'removed' : 'added';
my $field_object = $self->_chart_fields->{$field}
|| ThrowCodeError("invalid_field_name", {field => $field});
my $field_id = $field_object->id;
# Also, don't allow searching the _accessible stuff via quicksearch
# (both because it's unnecessary and because otherwise
# "reporter_accessible" and "reporter" both match "rep".
- delete @full_map{
- qw(rep_platform bug_status bug_file_loc bug_group
+ delete @full_map{qw(rep_platform bug_status bug_file_loc bug_group
bug_severity bug_status
status_whiteboard
- cclist_accessible reporter_accessible)
- };
+ cclist_accessible reporter_accessible)};
Bugzilla::Hook::process('quicksearch_map', {'map' => \%full_map});
}
# List of quicksearch-specific CGI parameters to get rid of.
- my @params_to_strip = ('quicksearch', 'load', 'run');
+ my @params_to_strip = ('quicksearch', 'load', 'run');
my $modified_query_string = $cgi->canonicalise_query(@params_to_strip);
if ($cgi->param('load')) {
return 0 if !defined $qsword || length($qsword) <= 1;
my $firstChar = substr($qsword, 0, 1);
- my $baseWord = substr($qsword, 1);
+ my $baseWord = substr($qsword, 1);
my @subWords = split(/,/, $baseWord);
if ($firstChar eq '#') {
# Check if we match, as a starting substring, exactly one field.
my @field_names = keys %$field_map;
- my @matches = grep { $_ =~ /^\Q$field\E/ } @field_names;
+ my @matches = grep { $_ =~ /^\Q$field\E/ } @field_names;
# Eliminate duplicates that are actually the same field
# (otherwise "assi" matches both "assignee" and "assigned_to", and
ThrowCodeError('bad_arg', {argument => 'name', function => "${class}::new"});
}
my $condition = 'userid = ? AND name = ?';
- my $user_id = blessed $user ? $user->id : $user;
+ my $user_id = blessed $user ? $user->id : $user;
detaint_natural($user_id)
|| ThrowCodeError('param_must_be_numeric',
{function => $class . '::_init', param => 'user'});
return unless scalar @$searches;
- my @query_ids = map { $_->id } @$searches;
+ my @query_ids = map { $_->id } @$searches;
my $queries_in_footer = $dbh->selectcol_arrayref(
'SELECT namedquery_id
FROM namedqueries_link_in_footer
# We only cache link_in_footer for the current Bugzilla->user.
return $self->{link_in_footer} if exists $self->{link_in_footer} && !$user;
- my $user_id = $user ? $user->id : Bugzilla->user->id;
+ my $user_id = $user ? $user->id : Bugzilla->user->id;
my $link_in_footer = Bugzilla->dbh->selectrow_array(
'SELECT 1 FROM namedqueries_link_in_footer
WHERE namedquery_id = ? AND user_id = ?', undef, $self->id, $user_id
sub new {
my $invocant = shift;
- my $class = ref($invocant) || $invocant;
+ my $class = ref($invocant) || $invocant;
# Create a ref to an empty hash and bless it
my $self = {};
# If no Accept-Language is present it uses the defined default
# Templates may also be found in the extensions/ tree
sub _include_path {
- my $lang = shift || '';
+ my $lang = shift || '';
my $cache = Bugzilla->request_cache;
$cache->{"template_include_path_$lang"}
||= template_include_path({language => $lang});
my @parts;
my @my_sizes = @$sizes; # Copy this so we don't modify the input array.
foreach my $string (@$args) {
- my $size = shift @my_sizes;
+ my $size = shift @my_sizes;
my @pieces = split("\n", wrap_hard($string, $size));
push(@parts, \@pieces);
}
my ($context, $isinactive) = @_;
return sub {
return $isinactive ? '<span class="bz_inactive">' . $_[0] . '</span>' : $_[0];
- }
+ }
},
1
],
my ($context, $isclosed) = @_;
return sub {
return $isclosed ? '<span class="bz_closed">' . $_[0] . '</span>' : $_[0];
- }
+ }
},
1
],
my ($context, $isobsolete) = @_;
return sub {
return $isobsolete ? '<span class="bz_obsolete">' . $_[0] . '</span>' : $_[0];
- }
+ }
},
1
],
my $dbh = Bugzilla->dbh;
# Update group settings.
- my $sth_add_mapping = $dbh->prepare(
- qq{INSERT INTO user_group_map (
+ my $sth_add_mapping = $dbh->prepare(qq{INSERT INTO user_group_map (
user_id, group_id, isbless, grant_type
) VALUES (
?, ?, ?, ?
)
}
);
- my $sth_remove_mapping = $dbh->prepare(
- qq{DELETE FROM user_group_map
+ my $sth_remove_mapping = $dbh->prepare(qq{DELETE FROM user_group_map
WHERE user_id = ?
AND group_id = ?
AND isbless = ?
# prevents people from writing over their whole
# recent-search list by just refreshing a saved search
# (which doesn't have list_id in the header) over and over.
- my $list_string = join(',', @$bug_ids);
+ my $list_string = join(',', @$bug_ids);
my $existing_search = Bugzilla::Search::Recent->match(
{user_id => $self->id, bug_list => $list_string});
# Add all its members to the FIFO check list
# %group_membership contains arrays of group members
# for all groups. Accessible by group number.
- my $members = $group_membership{$member_id};
+ my $members = $group_membership{$member_id};
my @new_to_check = grep(!$checked_groups{$_}, @$members);
push(@$groups_to_check, @new_to_check);
# We will restrict the list to products the user can see.
my $selectable_products = $self->get_selectable_products;
- my @products = grep { $product_map{$_->id} } @$selectable_products;
+ my @products = grep { $product_map{$_->id} } @$selectable_products;
return \@products;
}
# Bugzilla::Bug->update automatically removes updated bugs
# from the cache to force them to be checked again.
my $visible_cache = $self->{_visible_bugs_cache} ||= {};
- my @check_ids = grep(!exists $visible_cache->{$_}, @bug_ids);
+ my @check_ids = grep(!exists $visible_cache->{$_}, @bug_ids);
if (@check_ids) {
foreach my $id (@check_ids) {
my ($self) = @_;
if (!defined $self->{selectable_classifications}) {
- my $products = $self->get_selectable_products;
+ my $products = $self->get_selectable_products;
my %class_ids = map { $_->classification_id => 1 } @$products;
$self->{selectable_classifications}
sub check_can_admin_flagtype {
my ($self, $flagtype_id) = @_;
- my $flagtype = Bugzilla::FlagType->check({id => $flagtype_id});
+ my $flagtype = Bugzilla::FlagType->check({id => $flagtype_id});
my $can_fully_edit = 1;
if (!$self->in_group('editcomponents')) {
);
$sth->execute($id, GRANT_REGEXP);
- my $group_insert = $dbh->prepare(
- q{INSERT INTO user_group_map
+ my $group_insert = $dbh->prepare(q{INSERT INTO user_group_map
(user_id, group_id, isbless, grant_type)
VALUES (?, ?, 0, ?)}
);
- my $group_delete = $dbh->prepare(
- q{DELETE FROM user_group_map
+ my $group_delete = $dbh->prepare(q{DELETE FROM user_group_map
WHERE user_id = ?
AND group_id = ?
AND isbless = 0
# We cannot |use| it, because Component.pm already |use|s User.pm.
require Bugzilla::Component;
- my @comp_ids = map { $_->{'id'} } @$list;
+ my @comp_ids = map { $_->{'id'} } @$list;
my $components = Bugzilla::Component->new_from_list(\@comp_ids);
my @prod_list;
}
sub match_field {
- my $fields = shift; # arguments as a hash
- my $data = shift || Bugzilla->input_params; # hash to look up fields in
+ my $fields = shift; # arguments as a hash
+ my $data = shift || Bugzilla->input_params; # hash to look up fields in
my $behavior = shift || 0; # A constant that tells us how to act
my $matches = {}; # the values sent to the template
my $matchsuccess = 1; # did the match fail?
# Add the creation date to the profiles_activity table.
# $who is the user who created the new user account, i.e. either an
# admin or the new user himself.
- my $who = Bugzilla->user->id || $user->id;
+ my $who = Bugzilla->user->id || $user->id;
my $creation_date_fieldid = get_field_id('creation_ts');
$dbh->do(
# do check() and pull all the user data from the database.
sub login_to_id {
my ($login, $throw_error) = @_;
- my $dbh = Bugzilla->dbh;
+ my $dbh = Bugzilla->dbh;
my $cache = Bugzilla->request_cache->{user_login_to_id} ||= {};
# We cache lookups because this function showed up as taking up a
my $setting_name = shift;
my $user_id = shift;
- my $class = ref($invocant) || $invocant;
+ my $class = ref($invocant) || $invocant;
my $subclass = '';
# Create a ref to an empty hash and bless it
VALUES (?, ?, 1, ?)}, undef, ($name, $default_value, $subclass)
);
- my $sth = $dbh->prepare(
- q{INSERT INTO setting_value (name, value, sortindex)
+ my $sth = $dbh->prepare(q{INSERT INTO setting_value (name, value, sortindex)
VALUES (?, ?, ?)}
);
my $dbh = Bugzilla->dbh;
my $cache_key = "user_settings.$user_id";
- my $rows = Bugzilla->memcached->get_config({key => $cache_key});
+ my $rows = Bugzilla->memcached->get_config({key => $cache_key});
if (!$rows) {
$rows = $dbh->selectall_arrayref(
q{SELECT name, default_value, is_enabled, setting_value, subclass
my ($setting_name, $default_value, $is_enabled) = @_;
my $dbh = Bugzilla->dbh;
- my $sth = $dbh->prepare(
- q{UPDATE setting
+ my $sth = $dbh->prepare(q{UPDATE setting
SET default_value = ?, is_enabled = ?
WHERE name = ?}
);
if (!Bugzilla->feature('html_desc')) {
my $safe = join('|', @allow);
- my $chr = chr(1);
+ my $chr = chr(1);
# First, escape safe elements.
$text =~ s#<($safe)>#$chr$1$chr#go;
push(@allow, qw(a blockquote q span));
# Allowed protocols.
- my $safe_protocols = join('|', SAFE_PROTOCOLS);
+ my $safe_protocols = join('|', SAFE_PROTOCOLS);
my $protocol_regexp = qr{(^(?:$safe_protocols):|^[^:]+$)}i;
# Deny all elements and attributes unless explicitly authorized.
if (!Bugzilla->user->id) {
my @emails = Email::Address->parse($toencode);
if (scalar @emails) {
- my @hosts = map { quotemeta($_->host) } @emails;
+ my @hosts = map { quotemeta($_->host) } @emails;
my $hosts_re = join('|', @hosts);
$toencode =~ s/\@(?:$hosts_re)//g;
return $toencode;
}
sub remote_ip {
- my $ip = $ENV{'REMOTE_ADDR'} || '127.0.0.1';
+ my $ip = $ENV{'REMOTE_ADDR'} || '127.0.0.1';
my @proxies = split(/[\s,]+/, Bugzilla->params->{'inbound_proxies'});
# If the IP address is one of our trusted proxies, then we look at
if ($ts) {
$date2 = time2str("%Y-%m-%d", $ts);
- $date =~ s/(\d+)-0*(\d+?)-0*(\d+?)/$1-$2-$3/;
+ $date =~ s/(\d+)-0*(\d+?)-0*(\d+?)/$1-$2-$3/;
$date2 =~ s/(\d+)-0*(\d+?)-0*(\d+?)/$1-$2-$3/;
}
my $ret = ($ts && $date eq $date2);
}
my $condition = 'product_id = ? AND value = ?';
- my @values = ($product->id, $name);
+ my @values = ($product->id, $name);
$param = {condition => $condition, values => \@values};
}
foreach my $field (@fields) {
my $visibility_field
= $field->visibility_field ? $field->visibility_field->name : undef;
- my $vis_values = $field->visibility_values;
+ my $vis_values = $field->visibility_values;
my $value_field = $field->value_field ? $field->value_field->name : undef;
my (@values, $has_values);
or $field->name eq 'keywords')
{
$has_values = 1;
- @values = @{$self->_legal_field_values({field => $field})};
+ @values = @{$self->_legal_field_values({field => $field})};
}
if (grep($_ eq $field->name, PRODUCT_SPECIFIC_FIELDS)) {
);
if ($has_values) {
$field_data{value_field} = $self->type('string', $value_field);
- $field_data{values} = \@values;
+ $field_data{values} = \@values;
}
push(@fields_out, filter $params, \%field_data);
}
my %comments;
if (scalar @$comment_ids) {
- my @ids = map { trim($_) } @$comment_ids;
+ my @ids = map { trim($_) } @$comment_ids;
my $comment_data = Bugzilla::Comment->new_from_list(\@ids);
# See if we were passed any invalid comment ids.
my %changes = %{$all_changes{$bug->id}};
foreach my $field (keys %changes) {
- my $change = $changes{$field};
+ my $change = $changes{$field};
my $api_field = $api_name{$field} || $field;
# We normalize undef to an empty string, so that the API
my %retval;
foreach my $extension (@{Bugzilla->extensions}) {
my $version = $extension->VERSION || 0;
- my $name = $extension->NAME;
+ my $name = $extension->NAME;
$retval{$name}->{version} = $self->type('string', $version);
}
return {extensions => \%retval};
# Now, convert dateTime fields on input.
$self->_bz_method_name =~ /^(\S+)\.(\S+)$/;
my ($class, $method) = ($1, $2);
- my $pkg = $self->{dispatch_path}->{$class};
+ my $pkg = $self->{dispatch_path}->{$class};
my @date_fields = @{$pkg->DATE_FIELDS->{$method} || []};
foreach my $field (@date_fields) {
if (defined $params->{$field}) {
# 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 $response = $self->response_header(STATUS_OK, "");
my $options_string = join(', ', @{$self->bz_rest_options});
$response->header(
'Allow' => $options_string,
my $result = {};
if (exists $json_data->{error}) {
$result = $json_data->{error};
- $result->{error} = $self->type('boolean', 1);
+ $result->{error} = $self->type('boolean', 1);
$result->{documentation} = REST_DOC;
delete $result->{'name'}; # Remove JSONRPCError
}
# Parse the Accept header, and save type name, score, and position.
my @accept_types = split /,/, $self->cgi->http('accept') || '';
- my $order = 0;
+ my $order = 0;
for my $accept_type (@accept_types) {
my ($weight) = ($accept_type =~ /q=(\d\.\d+|\d+)/);
my ($name) = ($accept_type =~ m#(\S+/[^;]+)#);
my $super_method = "SUPER::$method";
return $self->$super_method($value);
}
- }
+ }
}
}
}
$attachments{$field_name} = $attachment;
}
- my @args = map { $_ . '=' . $attachments{$_}->id } @field_names;
+ my @args = map { $_ . '=' . $attachments{$_}->id } @field_names;
my $cgi_params = $cgi->canonicalise_query(@field_names, 't', 'Bugzilla_login',
'Bugzilla_password');
push(@args, $cgi_params) if $cgi_params;
# The token is valid. Delete the content of the attachment.
my $msg;
$vars->{'attachment'} = $attachment;
- $vars->{'reason'} = clean_text($cgi->param('reason') || '');
+ $vars->{'reason'} = clean_text($cgi->param('reason') || '');
$template->process("attachment/delete_reason.txt.tmpl", $vars, \$msg)
|| ThrowTemplateError($template->error());
$vars->{'search_id'} = $query_id;
}
$params = new Bugzilla::CGI($buffer);
- $order = $params->param('order') || $order;
+ $order = $params->param('order') || $order;
}
elsif ($remaction eq "runseries") {
$vars->{'columns'} = $columns;
$vars->{'displaycolumns'} = \@displaycolumns;
-$vars->{'openstates'} = [BUG_STATE_OPEN];
+$vars->{'openstates'} = [BUG_STATE_OPEN];
$vars->{'closedstates'} = [map { $_->name } closed_bug_statuses()];
# The iCal file needs priorities ordered from 1 to 9 (highest to lowest)
= _get_common_flag_types([keys %$bugcomponentids]);
# Convert bug statuses to their ID.
- my @bug_statuses = map { $dbh->quote($_) } keys %$bugstatuses;
+ my @bug_statuses = map { $dbh->quote($_) } keys %$bugstatuses;
my $bug_status_ids = $dbh->selectcol_arrayref(
'SELECT id FROM bug_status
WHERE ' . $dbh->sql_in('value', \@bug_statuses)
if ($format->{'extension'} eq "html") {
my $list_id = $cgi->param('list_id') || $cgi->param('regetlastlist');
- my $search = $user->save_last_search(
+ my $search = $user->save_last_search(
{bugs => \@bugidlist, order => $order, vars => $vars, list_id => $list_id});
$cgi->param('list_id', $search->id) if $search;
$contenttype = "text/html";
# series_id they apply to (e.g. subscribe, unsubscribe).
my @actions = grep(/^action-/, $cgi->param());
if ($actions[0] && $actions[0] =~ /^action-([^\d]+)(\d*)$/) {
- $action = $1;
+ $action = $1;
$series_id = $2 if $2;
}
# Read in the "answers" file if it exists, for running in
# non-interactive mode.
my $answers_file = $ARGV[0];
-my $silent = $answers_file && !$switch{'verbose'};
+my $silent = $answers_file && !$switch{'verbose'};
print(install_string('header', get_version_and_os()) . "\n") unless $silent;
exit 0 if $switch{'version'};
@collist = DEFAULT_COLUMN_LIST;
}
-$vars->{'collist'} = \@collist;
+$vars->{'collist'} = \@collist;
$vars->{'splitheader'} = $cgi->cookie('SPLITHEADER') ? 1 : 0;
$vars->{'buffer'} = $cgi->query_string();
my $when = localtime(time);
my $dbh = Bugzilla->dbh;
- my $file = join '/', $dir, $product->id;
+ my $file = join '/', $dir, $product->id;
my $exists = -f $file;
# if the file exists, get the old status and resolution list for that product.
}
if (!$exists || scalar(@data)) {
- my $fields = join('|', ('DATE', @statuses, @resolutions));
+ my $fields = join('|', ('DATE', @statuses, @resolutions));
my $product_name = $product->name;
print DATA <<FIN;
# Bugzilla Daily Bug Stats
}
if (open DATA, ">", $file) {
- my $fields = join('|', ('DATE', @statuses, @resolutions));
+ my $fields = join('|', ('DATE', @statuses, @resolutions));
my $product_name = $product->name;
print DATA <<FIN;
# Bugzilla Daily Bug Stats
# (days_since_epoch + series_id) % frequency = 0. So they'll run every
# <frequency> days, but the start date depends on the series_id.
my $days_since_epoch = int(time() / (60 * 60 * 24));
- my $today = today_dash();
+ my $today = today_dash();
# We save a copy of the main $dbh and then switch to the shadow and get
# that one too. Remember, these may be the same.
my ($total) = $source_db->selectrow_array("SELECT COUNT(*) FROM $table");
my $select_query = "SELECT " . join(',', @table_columns) . " FROM $table";
- my $select_sth = $source_db->prepare($select_query);
+ my $select_sth = $source_db->prepare($select_query);
$select_sth->execute();
my $insert_query
$Data::Dumper::Deparse = 0;
my $sysname = get_text('term', {term => 'Bugzilla'});
-my $term = new Term::ReadLine "$sysname Console";
+my $term = new Term::ReadLine "$sysname Console";
read_history($term);
END { write_history($term) }
next if $file =~ /install-requirements/;
print "Moving $file code into Extension.pm...\n";
my ($modules, $code) = process_code_file($file);
- my @code_lines = map {" $_"} @$code;
+ my @code_lines = map {" $_"} @$code;
my $code_string = join('', @code_lines);
$code_string =~ s/Bugzilla->hook_args/\$args/g;
$code_string =~ s/my\s+\$args\s+=\s+\$args;//gs;
push(@subroutines, $subroutine);
}
- my %seen_modules = map { trim($_) => 1 } @all_modules;
+ my %seen_modules = map { trim($_) => 1 } @all_modules;
my $module_string = join("\n", sort keys %seen_modules);
my $subroutine_string = join("\n", @subroutines);
return ($module_string, $subroutine_string);
my $dbh = Bugzilla->dbh;
# Display the help if called with --help or -?.
-my $help = 0;
+my $help = 0;
my $result = GetOptions("help|?" => \$help);
pod2usage(0) if $help;
# Get all columns to consider. There is always at least
# one column given: the one to update.
- my @columns = split(/[\s]+/, $column_list);
+ my @columns = split(/[\s]+/, $column_list);
my $cols_to_check = join(' AND ', map {"$_ = ?"} @columns);
# The first column of the list is the one to update.
AND $column != ''"
);
- my @pk_array = map {"$_ = ?"} split(',', $pk);
- my $pk_where = join(' AND ', @pk_array);
+ my @pk_array = map {"$_ = ?"} split(',', $pk);
+ my $pk_where = join(' AND ', @pk_array);
my $update_sth = $dbh->prepare("UPDATE $table SET $column = ? WHERE $pk_where");
$sth->execute();
# Wide characters cause md5_base64() to die.
my $digest_data = utf8::is_utf8($data) ? Encode::encode_utf8($data) : $data;
- my $digest = md5_base64($digest_data);
+ my $digest = md5_base64($digest_data);
my @primary_keys = reverse split(',', $pk);
foreach my $e (@downlines) {
$row_count++;
my $even_or_odd = $row_count % 2 ? 'even' : 'odd';
- my $name = esc($e->[0]);
+ my $name = esc($e->[0]);
my $path = join("/", '.', esc(@{$e->[3]})) . $Pod::Simple::HTML::HTML_EXTENSION;
my $description = $self->{bugzilla_desc}->{$name} || '';
$description = esc($description);
{group => 'admin', action => 'edit', object => 'custom_fields'});
my $action = trim($cgi->param('action') || '');
-my $token = $cgi->param('token');
+my $token = $cgi->param('token');
print $cgi->header();
{group => "creategroups", action => "edit", object => "groups"});
my $action = trim($cgi->param('action') || '');
-my $token = $cgi->param('token');
+my $token = $cgi->param('token');
# CheckGroupID checks that a positive integer is given and is
# actually a valid group ID. If all tests are successful, the
if ($action eq 'update') {
check_token_data($token, 'edit_milestone');
my $milestone_old_name = trim($cgi->param('milestoneold') || '');
- my $milestone = Bugzilla::Milestone->check(
+ my $milestone = Bugzilla::Milestone->check(
{product => $product, name => $milestone_old_name});
$milestone->set_name($milestone_name);
else {
# Only keep classifications containing at least one product
# which you can administer.
- my $products = $user->get_products_by_permission('editcomponents');
+ my $products = $user->get_products_by_permission('editcomponents');
my %class_ids = map { $_->classification_id => 1 } @$products;
$class = Bugzilla::Classification->new_from_list([keys %class_ids]);
}
@$products = grep { $_->classification_id == $classification->id } @$products;
}
}
- $vars->{'products'} = $products;
+ $vars->{'products'} = $products;
$vars->{'showbugcounts'} = $cgi->param('showbugcounts') ? 1 : 0;
$template->process("admin/products/list.html.tmpl", $vars)
if ($action eq 'update') {
check_token_data($token, 'edit_product');
my $product_old_name = trim($cgi->param('product_old_name') || '');
- my $product = $user->check_can_admin_product($product_old_name);
+ my $product = $user->check_can_admin_product($product_old_name);
$product->set_all({
name => $product_name,
{group => "tweakparams", action => "modify", object => "settings"});
my $action = trim($cgi->param('action') || '');
-my $token = $cgi->param('token');
+my $token = $cgi->param('token');
if ($action eq 'update') {
check_token_data($token, 'edit_settings');
# often-used variables
#
my $action = trim($cgi->param('action') || '');
-my $token = $cgi->param('token');
+my $token = $cgi->param('token');
#
# field = '' -> Show nice list of fields
# to be altered or deleted
# Check schedules for changes
- my $schedules = Bugzilla::Whine::Schedule->match({eventid => $eventid});
+ my $schedules = Bugzilla::Whine::Schedule->match({eventid => $eventid});
my @scheduleids = ();
foreach my $schedule (@$schedules) {
push @scheduleids, $schedule->id;
my $schedules = Bugzilla::Whine::Schedule->match({eventid => $event_id});
foreach my $schedule (@$schedules) {
my $mailto_type = $schedule->mailto_is_group ? MAILTO_GROUP : MAILTO_USER;
- my $mailto = '';
+ my $mailto = '';
if ($mailto_type == MAILTO_USER) {
$mailto = $schedule->mailto->login;
}
{group => 'admin', action => 'modify', object => 'workflow'});
my $action = $cgi->param('action') || 'edit';
-my $token = $cgi->param('token');
+my $token = $cgi->param('token');
sub get_workflow {
my $dbh = Bugzilla->dbh;
# Make it possible to remove CCs.
if ($fields{'removecc'}) {
- $fields{'cc'} = [split(',', $fields{'removecc'})];
+ $fields{'cc'} = [split(',', $fields{'removecc'})];
$fields{'removecc'} = 1;
}
my @parts = $email->parts;
my $body;
foreach my $part (@parts) {
- my $ct = $part->content_type || 'text/plain';
+ my $ct = $part->content_type || 'text/plain';
my $charset = 'iso-8859-1';
# The charset may be quoted.
# We need to ensure that we respect the 'insider' status of
# the first comment, if it has one. Either way, make a note
# that this bug was cloned from another bug.
- my $bug_desc = $cloned_bug->comments({order => 'oldest_to_newest'})->[0];
+ my $bug_desc = $cloned_bug->comments({order => 'oldest_to_newest'})->[0];
my $isprivate = $bug_desc->is_private;
$vars->{'comment'} = "";
return unless $args->{attributes}->{mimetype} eq 'image/bmp';
my $data = ${$args->{data}};
- my $img = Image::Magick->new(magick => 'bmp');
+ my $img = Image::Magick->new(magick => 'bmp');
# $data is a filehandle.
if (ref $data) {
return unless $args->{error} eq 'bad_page_cgi_id';
my $page_id = $args->{vars}->{page_id};
- my $login = Bugzilla->user->identity || "Someone";
+ my $login = Bugzilla->user->identity || "Someone";
warn "$login attempted to access page.cgi with id = $page_id";
my $page = $args->{message};
sub install_update_db {
my $dbh = Bugzilla->dbh;
- my $should_rename = $dbh->selectrow_array(
- q{SELECT 1 FROM bug_see_also
+ my $should_rename = $dbh->selectrow_array(q{SELECT 1 FROM bug_see_also
WHERE class IN ('Bugzilla::BugUrl::Rietveld',
'Bugzilla::BugUrl::ReviewBoard')}
);
use constant CMT_MOVED_TO => 4;
sub install_update_db {
- my $reso_type = Bugzilla::Field::Choice->type('resolution');
+ my $reso_type = Bugzilla::Field::Choice->type('resolution');
my $moved_reso = $reso_type->new({name => 'MOVED'});
# We make the MOVED resolution inactive, so that it doesn't show up
my $needs_rebuild;
foreach my $id (keys %cached_counts) {
my $cached_count = $cached_counts{$id};
- my $real_count = $real_counts{$id} || 0;
+ my $real_count = $real_counts{$id} || 0;
if ($cached_count < 0) {
$status->('voting_count_alert', {id => $id}, 'alert');
}
($who->id, $product->id)
);
- my %votes = map { $_->[0] => $_->[1] } @$vote_list;
+ my %votes = map { $_->[0] => $_->[1] } @$vote_list;
my @bug_ids = sort keys %votes;
# Exclude bugs that the user can no longer see.
# If a user votes for a bug, or the number of votes required to
# confirm a bug has been reduced, check if the bug is now confirmed.
sub _confirm_if_vote_confirmed {
- my $id = shift;
+ my $id = shift;
my $bug = ref $id ? $id : new Bugzilla::Bug({id => $id, cache => 1});
my $ret = 0;
$err .= " Using default product and component set ";
$err .= "at the command line.\n";
- $product = new Bugzilla::Product({name => $default_product_name});
+ $product = new Bugzilla::Product({name => $default_product_name});
$component = new Bugzilla::Component(
{name => $default_component_name, product => $product});
if (!$component) {
$query .= ")";
$dbh->do($query, undef, @values);
- my $id = $dbh->bz_last_key('bugs', 'bug_id');
+ my $id = $dbh->bz_last_key('bugs', 'bug_id');
my $bug_obj = Bugzilla::Bug->new($id);
# We are almost certain to get some uninitialized warnings
Bugzilla::Hook::process('post_bug_after_creation', {vars => $vars});
my $recipients = {changer => $user};
-my $bug_sent = Bugzilla::BugMail::Send($id, $recipients);
+my $bug_sent = Bugzilla::BugMail::Send($id, $recipients);
$bug_sent->{type} = 'created';
$bug_sent->{id} = $id;
my @all_mail_results = ($bug_sent);
my $vars = {};
my $action = $cgi->param('action') || "";
-my $token = $cgi->param('token');
+my $token = $cgi->param('token');
if ($action eq "show") {
my $user = Bugzilla->login(LOGIN_REQUIRED);
my $target_login = $cgi->param('target_login');
- my $reason = $cgi->param('reason') || '';
+ my $reason = $cgi->param('reason') || '';
# At this point, the user is logged in. However, if they used a method
# where they could have provided a username/password (i.e. CGI), but they
Bugzilla->login();
my $action = $cgi->param('action') || 'menu';
-my $token = $cgi->param('token');
+my $token = $cgi->param('token');
if ($action eq "menu") {
foreach my $dataset (@data) {
my $datasets = {};
- $datasets->{'value'} = $dataset;
+ $datasets->{'value'} = $dataset;
$datasets->{'selected'} = $default_sel{$dataset} ? 1 : 0;
push(@datasets, $datasets);
}
# Filenames must not be guessable as they can point to products
# you are not allowed to see. Also, different projects can have
# the same product IDs.
- my $project = bz_locations()->{'project'} || '';
+ my $project = bz_locations()->{'project'} || '';
my $image_file = join(':', ($project, $product->id, @datasets));
- my $key = Bugzilla->localconfig->{'site_wide_secret'};
+ my $key = Bugzilla->localconfig->{'site_wide_secret'};
$image_file = hmac_sha256_base64($image_file, $key) . '.png';
$image_file =~ s/\+/-/g;
$image_file =~ s/\//_/g;
my $product_in_title = $product->id ? $product->name : 'All Products';
my @fields;
- my @labels = qw(DATE);
+ my @labels = qw(DATE);
my %datasets = map { $_ => 1 } @$datasets;
my %data = ();
}
my $img = Chart::Lines->new(800, 600);
- my $i = 0;
+ my $i = 0;
my $MAXTICKS = 20; # Try not to show any more x ticks than this.
my $skip = 1;
}
else {
my $flagtypes = get_flag_types();
- my @types = ('all', @$flagtypes);
+ my @types = ('all', @$flagtypes);
my $vars = {};
$vars->{'types'} = \@types;
my $na = CONTROLMAPNA;
my $shown = CONTROLMAPSHOWN;
- my $insertsth = $dbh->prepare(
- qq{INSERT INTO group_control_map
+ my $insertsth = $dbh->prepare(qq{INSERT INTO group_control_map
(group_id, product_id, membercontrol, othercontrol)
VALUES (?, ?, $shown, $na)}
);
- my $updatesth = $dbh->prepare(
- qq{UPDATE group_control_map
+ my $updatesth = $dbh->prepare(qq{UPDATE group_control_map
SET membercontrol = $shown
WHERE group_id = ?
AND product_id = ?}
Status('send_bugmail_start');
my $time = $dbh->sql_date_math('NOW()', '-', 30, 'MINUTE');
- my $list = $dbh->selectcol_arrayref(
- qq{
+ my $list = $dbh->selectcol_arrayref(qq{
SELECT bug_id
FROM bugs
WHERE (lastdiffed IS NULL
Status('keyword_check_start');
my %keywordids;
- my $keywords = $dbh->selectall_arrayref(
- q{SELECT id, name
+ my $keywords = $dbh->selectall_arrayref(q{SELECT id, name
FROM keyworddefs}
);
}
}
- my $sth = $dbh->prepare(
- q{SELECT bug_id, keywordid
+ my $sth = $dbh->prepare(q{SELECT bug_id, keywordid
FROM keywords
ORDER BY bug_id, keywordid}
);
my ($middlesql, $errortext, $repairparam, $repairtext) = @_;
my $dbh = Bugzilla->dbh;
- my $badbugs = $dbh->selectcol_arrayref(
- qq{SELECT DISTINCT bugs.bug_id
+ my $badbugs = $dbh->selectcol_arrayref(qq{SELECT DISTINCT bugs.bug_id
FROM $middlesql
ORDER BY bugs.bug_id}
);
Status('unsent_bugmail_check');
-my $time = $dbh->sql_date_math('NOW()', '-', 30, 'MINUTE');
-my $badbugs = $dbh->selectcol_arrayref(
- qq{
+my $time = $dbh->sql_date_math('NOW()', '-', 30, 'MINUTE');
+my $badbugs = $dbh->selectcol_arrayref(qq{
SELECT bug_id
FROM bugs
WHERE (lastdiffed IS NULL OR lastdiffed < delta_ts)
Bugzilla::Bug->preload(\@bugs);
-$vars->{'bugs'} = [@bugs, @illegal_bugs];
+$vars->{'bugs'} = [@bugs, @illegal_bugs];
$vars->{'marks'} = \%marks;
my @bugids = map { $_->bug_id } grep { !$_->error } @bugs;
$rankdir = 'TB';
}
-my $display = $cgi->param('display') || 'tree';
+my $display = $cgi->param('display') || 'tree';
my $webdotdir = bz_locations()->{'webdotdir'};
my ($fh, $filename) = File::Temp::tempfile(
my @stack = keys(%baselist);
if ($display eq 'web') {
- my $sth = $dbh->prepare(
- q{SELECT blocked, dependson
+ my $sth = $dbh->prepare(q{SELECT blocked, dependson
FROM dependencies
WHERE blocked = ? OR dependson = ?}
);
$seen{$k} = 1;
}
-my $sth = $dbh->prepare(
- q{SELECT bug_status, resolution, short_desc
+my $sth = $dbh->prepare(q{SELECT bug_status, resolution, short_desc
FROM bugs
WHERE bugs.bug_id = ?}
);
# Generate the tree of bugs that this bug depends on and a list of IDs
# appearing in the tree.
my $dependson_tree = {$id => $bug};
-my $dependson_ids = {};
+my $dependson_ids = {};
GenerateTree($id, "dependson", 1, $dependson_tree, $dependson_ids);
$vars->{'dependson_tree'} = $dependson_tree;
$vars->{'dependson_ids'} = [keys(%$dependson_ids)];
# Generate the tree of bugs that this bug blocks and a list of IDs
# appearing in the tree.
my $blocked_tree = {$id => $bug};
-my $blocked_ids = {};
+my $blocked_ids = {};
GenerateTree($id, "blocked", 1, $blocked_tree, $blocked_ids);
$vars->{'blocked_tree'} = $blocked_tree;
$vars->{'blocked_ids'} = [keys(%$blocked_ids)];
sub get_blocker_ids {
my ($bug_id, $unique) = @_;
$unique ||= {$bug_id => 1};
- my $deps = Bugzilla::Bug::EmitDependList("blocked", "dependson", $bug_id);
+ my $deps = Bugzilla::Bug::EmitDependList("blocked", "dependson", $bug_id);
my @unseen = grep { !$unique->{$_}++ } @$deps;
foreach $bug_id (@unseen) {
get_blocker_ids($bug_id, $unique);
ok(!$return_val, $file) or diag('--ERROR');
}
-my @testitems = (@Support::Files::testitems, @Support::Files::test_files);
+my @testitems = (@Support::Files::testitems, @Support::Files::test_files);
my $file_features = map_files_to_features();
# Test the scripts by compiling them
(scalar(@Support::Files::testitems) + scalar(@Support::Files::test_files))
* 6;
-my @testitems = (@Support::Files::test_files, @Support::Files::testitems);
+my @testitems = (@Support::Files::test_files, @Support::Files::testitems);
my @require_taint = qw(email_in.pl importxml.pl mod_perl.pl whine.pl);
foreach my $file (@testitems) {
foreach my $include_path (@include_paths) {
foreach my $path (@{$actual_files{$include_path}}) {
my $file = File::Spec->catfile($include_path, $path);
- $file =~ s/\s.*$//; # nuke everything after the first space
+ $file =~ s/\s.*$//; # nuke everything after the first space
$file =~ s|\\|/|g if ON_WINDOWS; # convert \ to / in path if on windows
$test_templates{$file} = () if $file =~ m#global/(code|user)-error\.html\.tmpl#;
my $verstring = "GD version $gd, libgd version $gdlib";
$gdlib =~ s/^([^\.]+)\..*/$1/;
- $gd =~ s/^([^\.]+)\..*/$1/;
+ $gd =~ s/^([^\.]+)\..*/$1/;
if ($gdlib == $gd) {
say "TEST-OK $verstring; Major versions match.";
# Test GD
eval {
my $image = new GD::Image(100, 100);
- my $black = $image->colorAllocate(0, 0, 0);
+ my $black = $image->colorAllocate(0, 0, 0);
my $white = $image->colorAllocate(255, 255, 255);
- my $red = $image->colorAllocate(255, 0, 0);
- my $blue = $image->colorAllocate(0, 0, 255);
+ my $red = $image->colorAllocate(255, 0, 0);
+ my $blue = $image->colorAllocate(0, 0, 255);
$image->transparent($white);
$image->rectangle(0, 0, 99, 99, $black);
$image->arc(50, 50, 95, 75, 0, 360, $blue);
# The new information given to us by the user.
my $new_watched_users = join(',', $cgi->param('new_watchedusers')) || '';
- my @new_watch_names = split(/[,\s]+/, $new_watched_users);
+ my @new_watch_names = split(/[,\s]+/, $new_watched_users);
my %new_watch_ids;
foreach my $username (@new_watch_names) {
my $user = Bugzilla->user;
my $api_keys = Bugzilla::User::APIKey->match({user_id => $user->id});
- $vars->{api_keys} = $api_keys;
+ $vars->{api_keys} = $api_keys;
$vars->{any_revoked} = grep { $_->revoked } @$api_keys;
}
my $is_enabled = grep { $_->NAME eq 'Voting' } @{Bugzilla->extensions};
$is_enabled || ThrowUserError('extension_disabled', {name => 'Voting'});
-my $cgi = Bugzilla->cgi;
+my $cgi = Bugzilla->cgi;
my $action = $cgi->param('action') || 'show_user';
if ($action eq "show_bug") {
my $sth = $dbh->prepare("SELECT name FROM groups " . "WHERE id=?");
$sth->execute($mailto);
my $groupname = $sth->fetch->[0];
- my $group_id = Bugzilla::Group::ValidateGroupName($groupname, $owner);
+ my $group_id = Bugzilla::Group::ValidateGroupName($groupname, $owner);
if ($group_id) {
my $glist = join(',', @{Bugzilla::Group->flatten_group_membership($group_id)});
$sth = $dbh->prepare(
push @{$thisquery->{'columnlist'}}, @searchfields;
my @orderstrings = split(/,\s*/, $searchparams->param('order') || '');
- my $search = new Bugzilla::Search(
+ my $search = new Bugzilla::Search(
'fields' => \@searchfields,
'params' => scalar $searchparams->Vars,
'user' => $args->{'recipient'}, # the search runs as the recipient
# if it's today
if ($daysinmonth[$now_month] == $now_day) {
my $month = $now_month + 1;
- $month = 1 if $month > 12;
+ $month = 1 if $month > 12;
$add_days = $daysinmonth[$month] + 1;
}
else {
foreach my $field (@multi_selects) {
my $new_value = create_legal_value($field, 6);
- my $name = $field->name;
+ my $name = $field->name;
$values{$name} = [$values{$name}, $new_value->name];
}
push(@{$values{'tag'}}, "6-tag-" . random());
# We need bug 6 to have a unique alias that is not a clone of bug 1's,
# so we get the alias separately from the other parameters.
- my $alias = $self->bug_create_value($number, 'alias');
+ my $alias = $self->bug_create_value($number, 'alias');
my $update_alias = $self->bug_update_value($number, 'alias');
# Otherwise, make bug 6 a clone of bug 1.
# These are necessary for the changedfrom tests.
my $extra_values = $self->_extra_bug_create_values->{$number};
- foreach my $field (
- qw(comments remaining_time percentage_complete
+ foreach my $field (qw(comments remaining_time percentage_complete
keyword_objects everconfirmed dependson blocked
- groups_in classification actual_time)
- )
+ groups_in classification actual_time))
{
$extra_values->{$field} = $bug->$field;
}
# writing this test, Bug->create doesn't support setting resolution).
#
# Same for see_also.
- my $timestamp = timestamp($number, $number - 1);
+ my $timestamp = timestamp($number, $number - 1);
my $creation_ts = $timestamp->ymd . ' ' . $timestamp->hms;
$bug->{creation_ts} = $creation_ts;
$dbh->do('UPDATE longdescs SET bug_when = ? WHERE bug_id = ?',
$update_params{cc} = {add => \@cc_add, remove => \@cc_remove};
my $see_also_remove = $bug->see_also;
my $see_also_add = [$update_params{see_also}];
- $update_params{see_also} = {add => $see_also_add, remove => $see_also_remove};
- $update_params{comment} = {body => $update_params{comment}};
+ $update_params{see_also} = {add => $see_also_add, remove => $see_also_remove};
+ $update_params{comment} = {body => $update_params{comment}};
$update_params{work_time} = $number;
# Setting work_time kills the remaining_time, so we need to
}
# Rollbacks won't get rid of bugs_fulltext entries, so we do that ourselves.
- my @bug_ids = map { $_->id } $self->bugs;
+ my @bug_ids = map { $_->id } $self->bugs;
my $bug_id_string = join(',', @bug_ids);
$dbh->do("DELETE FROM bugs_fulltext WHERE bug_id IN ($bug_id_string)");
$dbh->bz_rollback_transaction();
my $bug2 = $self->bug(2);
my $bug3 = $self->bug(3);
foreach my $number (1, 6) {
- my $bug = $self->bug($number);
+ my $bug = $self->bug($number);
my @original_delta = ($bug2->delta_ts, $bug3->delta_ts);
Bugzilla->set_user($bug->reporter);
$bug->set_dependencies([$bug2->id], [$bug3->id]);
'longdescs.count' => {
search => 1,
db_skip => ['Pg'],
- operator_ok => [
- qw(allwords allwordssubstr anywordssubstr casesubstring
+ operator_ok => [qw(allwords allwordssubstr anywordssubstr casesubstring
changedbefore changedafter greaterthan greaterthaneq
lessthan lessthaneq notregexp notsubstring
nowordssubstr regexp substring anywords
- notequals nowords equals anyexact)
- ],
+ notequals nowords equals anyexact)],
},
};
sub search_params {
my ($self) = @_;
- my %params = %{$self->test->{top_params} || {}};
+ my %params = %{$self->test->{top_params} || {}};
my $counter = 0;
foreach my $row (@{$self->test->{params}}) {
$row->{v} = $self->translate_value($row) if exists $row->{v};
sub debug_fail {
my ($self, $number, $results, $sql) = @_;
my @expected = @{$self->test->{contains}};
- my @results = sort map { $self->number($_) } map { $_->[0] } @$results;
+ my @results = sort map { $self->number($_) } map { $_->[0] } @$results;
return
" Value: '"
. $self->translated_value . "'\n"
if ($field =~ /^attach.+\.(.+)$/) {
my $attach_field = $1;
$attach_field = ATTACHMENT_FIELDS->{$attach_field} || $attach_field;
- @values = $self->_values_for($number, 'attachments', $attach_field);
+ @values = $self->_values_for($number, 'attachments', $attach_field);
}
elsif (my $flag_field = FLAG_FIELDS->{$field}) {
@values = $self->_values_for($number, 'flags', $flag_field);
# requestees.login_name is empty for most bugs (but checking
# blessed(undef) handles that.
# Values that come from %original_values aren't User objects.
- @values = map { blessed($_) ? $_->login : $_ } @values;
+ @values = map { blessed($_) ? $_->login : $_ } @values;
@values = grep { defined $_ } @values;
}
}
if (my $func = $self->test->{transform}) {
my $transformed = $func->(@bug_values);
- my $is_equal = $transformed eq $bug_values[0] ? 1 : 0;
+ my $is_equal = $transformed eq $bug_values[0] ? 1 : 0;
$self->transformed_value_was_equal($number, $is_equal);
$string_value = $transformed;
}
my $contains_known_broken = $self->contains_known_broken($number);
my %result_ids = map { $_->[0] => 1 } @$results;
- my $bug_id = $self->bug($number)->id;
+ my $bug_id = $self->bug($number)->id;
TODO: {
local $TODO = $contains_known_broken if $contains_known_broken;
sub new {
my $class = shift;
- my $self = {field_tests => [@_]};
+ my $self = {field_tests => [@_]};
return bless $self, $class;
}
projects / thirdparty / bugzilla.git / commitdiff
