<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;"># Copyright Â© 2009 RaphaÃ«l Hertzog &lt;hertzog@debian.org&gt;
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see &lt;https://www.gnu.org/licenses/&gt;.

=encoding utf8

=head1 NAME

Dpkg::Changelog::Entry - represents a changelog entry

=head1 DESCRIPTION

This class represents a changelog entry. It is composed
of a set of lines with specific purpose: a header line, changes lines, a
trailer line. Blank lines can be between those kind of lines.

=cut

package Dpkg::Changelog::Entry 1.01;

use strict;
use warnings;

use Carp;

use Dpkg::Gettext;
use Dpkg::ErrorHandling;
use Dpkg::Control::Changelog;

use overload
    '""' =&gt; \&amp;output,
    'eq' =&gt; sub { defined($_[1]) and "$_[0]" eq "$_[1]" },
    fallback =&gt; 1;

=head1 METHODS

=over 4

=item $entry = Dpkg::Changelog::Entry-&gt;new()

Creates a new object. It doesn't represent a real changelog entry
until one has been successfully parsed or built from scratch.

=cut

sub new {
    my $this = shift;
    my $class = ref($this) || $this;

    my $self = {
	header =&gt; undef,
	changes =&gt; [],
	trailer =&gt; undef,
	blank_after_header =&gt; [],
	blank_after_changes =&gt; [],
	blank_after_trailer =&gt; [],
    };
    bless $self, $class;
    return $self;
}

=item $str = $entry-&gt;output()

=item "$entry"

Get a string representation of the changelog entry.

=item $entry-&gt;output($fh)

Print the string representation of the changelog entry to a
filehandle.

=cut

sub _format_output_block {
    my $lines = shift;
    return join('', map { $_ . "\n" } @{$lines});
}

sub output {
    my ($self, $fh) = @_;
    my $str = '';
    $str .= $self-&gt;{header} . "\n" if defined($self-&gt;{header});
    $str .= _format_output_block($self-&gt;{blank_after_header});
    $str .= _format_output_block($self-&gt;{changes});
    $str .= _format_output_block($self-&gt;{blank_after_changes});
    $str .= $self-&gt;{trailer} . "\n" if defined($self-&gt;{trailer});
    $str .= _format_output_block($self-&gt;{blank_after_trailer});
    print { $fh } $str if defined $fh;
    return $str;
}

=item $entry-&gt;get_part($part)

Return either a string (for a single line) or an array ref (for multiple
lines) corresponding to the requested part. $part can be
"header, "changes", "trailer", "blank_after_header",
"blank_after_changes", "blank_after_trailer".

=cut

sub get_part {
    my ($self, $part) = @_;
    croak "invalid part of changelog entry: $part" unless exists $self-&gt;{$part};
    return $self-&gt;{$part};
}

=item $entry-&gt;set_part($part, $value)

Set the value of the corresponding part. $value can be a string
or an array ref.

=cut

sub set_part {
    my ($self, $part, $value) = @_;
    croak "invalid part of changelog entry: $part" unless exists $self-&gt;{$part};
    if (ref($self-&gt;{$part})) {
	if (ref($value)) {
	    $self-&gt;{$part} = $value;
	} else {
	    $self-&gt;{$part} = [ $value ];
	}
    } else {
	$self-&gt;{$part} = $value;
    }
}

=item $entry-&gt;extend_part($part, $value)

Concatenate $value at the end of the part. If the part is already a
multi-line value, $value is added as a new line otherwise it's
concatenated at the end of the current line.

=cut

sub extend_part {
    my ($self, $part, $value, @rest) = @_;
    croak "invalid part of changelog entry: $part" unless exists $self-&gt;{$part};
    if (ref($self-&gt;{$part})) {
	if (ref($value)) {
	    push @{$self-&gt;{$part}}, @$value;
	} else {
	    push @{$self-&gt;{$part}}, $value;
	}
    } elsif (defined $self-&gt;{$part}) {
        if (ref($value)) {
            $self-&gt;{$part} = [ $self-&gt;{$part}, @$value ];
        } else {
            $self-&gt;{$part} .= $value;
        }
    } else {
        $self-&gt;{$part} = $value;
    }
}

=item $is_empty = $entry-&gt;is_empty()

Returns 1 if the changelog entry doesn't contain anything at all.
Returns 0 as soon as it contains something in any of its non-blank
parts.

=cut

sub is_empty {
    my $self = shift;
    return !(defined($self-&gt;{header}) || defined($self-&gt;{trailer}) ||
	     scalar(@{$self-&gt;{changes}}));
}

=item $entry-&gt;normalize()

Normalize the content. Strip whitespaces at end of lines, use a single
empty line to separate each part.

=cut

sub normalize {
    my $self = shift;
    if (defined($self-&gt;{header})) {
	$self-&gt;{header} =~ s/\s+$//g;
	$self-&gt;{blank_after_header} = [''];
    } else {
	$self-&gt;{blank_after_header} = [];
    }
    if (scalar(@{$self-&gt;{changes}})) {
	s/\s+$//g foreach @{$self-&gt;{changes}};
	$self-&gt;{blank_after_changes} = [''];
    } else {
	$self-&gt;{blank_after_changes} = [];
    }
    if (defined($self-&gt;{trailer})) {
	$self-&gt;{trailer} =~ s/\s+$//g;
	$self-&gt;{blank_after_trailer} = [''];
    } else {
	$self-&gt;{blank_after_trailer} = [];
    }
}

=item $src = $entry-&gt;get_source()

Return the name of the source package associated to the changelog entry.

=cut

sub get_source {
    return;
}

=item $ver = $entry-&gt;get_version()

Return the version associated to the changelog entry.

=cut

sub get_version {
    return;
}

=item @dists = $entry-&gt;get_distributions()

Return a list of target distributions for this version.

=cut

sub get_distributions {
    return;
}

=item $ctrl = $entry-&gt;get_optional_fields()

Return a set of optional fields exposed by the changelog entry.
It always returns a L&lt;Dpkg::Control&gt; object (possibly empty though).

=cut

sub get_optional_fields {
    return Dpkg::Control::Changelog-&gt;new();
}

=item $urgency = $entry-&gt;get_urgency()

Return the urgency of the associated upload.

=cut

sub get_urgency {
    return;
}

=item $maint = $entry-&gt;get_maintainer()

Return the string identifying the person who signed this changelog entry.

=cut

sub get_maintainer {
    return;
}

=item $time = $entry-&gt;get_timestamp()

Return the timestamp of the changelog entry.

=cut

sub get_timestamp {
    return;
}

=item $time = $entry-&gt;get_timepiece()

Return the timestamp of the changelog entry as a L&lt;Time::Piece&gt; object.

This function might return undef if there was no timestamp.

=cut

sub get_timepiece {
    return;
}

=item $str = $entry-&gt;get_dpkg_changes()

Returns a string that is suitable for usage in a C&lt;Changes&gt; field
in the output format of C&lt;dpkg-parsechangelog&gt;.

=cut

sub get_dpkg_changes {
    my $self = shift;
    my $header = $self-&gt;get_part('header') // '';
    $header =~ s/\s+$//;
    return "\n$header\n\n" . join("\n", @{$self-&gt;get_part('changes')});
}

=back

=head1 CHANGES

=head2 Version 1.01 (dpkg 1.18.8)

New method: $entry-&gt;get_timepiece().

=head2 Version 1.00 (dpkg 1.15.6)

Mark the module as public.

=cut

1;
</pre></body></html>