commit parti for openSUSE:Factory

27 Apr 2018

Hello community,

here is the log from the commit of package parti for openSUSE:Factory checked in at 2018-04-27 16:09:05
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/parti (Old)
 and      /work/SRC/openSUSE:Factory/.parti.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "parti"

Fri Apr 27 16:09:05 2018 rev:7 rq:601612 version:1.18

Changes:
--------

--- /work/SRC/openSUSE:Factory/parti/parti.changes	2018-04-26 13:38:43.738546026 +0200
+++ /work/SRC/openSUSE:Factory/.parti.new/parti.changes	2018-04-27 16:09:12.238551218 +0200
@@ -1,0 +2,9 @@
+Thu Apr 26 14:05:19 UTC 2018 - wfeldt@opensuse.org
+
+- merge gh#wfeldt/parti#9
+- improve doc a bit
+- update git2log script to latest version
+- reference obs builds
+- 1.18
+
+--------------------------------------------------------------------

Old:
----
  parti-1.17.tar.xz

New:
----
  parti-1.18.tar.xz

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ parti.spec ++++++
--- /var/tmp/diff_new_pack.RjlFqh/_old	2018-04-27 16:09:12.738532880 +0200
+++ /var/tmp/diff_new_pack.RjlFqh/_new	2018-04-27 16:09:12.742532733 +0200
@@ -18,7 +18,7 @@
 
 
 Name:           parti
-Version:        1.17
+Version:        1.18
 Release:        0
 Summary:        Show partition table information
 License:        GPL-3.0

++++++ parti-1.17.tar.xz -> parti-1.18.tar.xz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/parti-1.17/README.md new/parti-1.18/README.md
--- old/parti-1.17/README.md	2018-04-25 15:37:55.000000000 +0200
+++ new/parti-1.18/README.md	2018-04-26 16:05:19.000000000 +0200
@@ -22,14 +22,34 @@
 So it can be used to verify the data your favorite partitioning tool has
 actually written.
 
+## Downloads
+
+Get the latest version from the [openSUSE Build Service](https://software.opensuse.org/package/parti).
+
 ## openSUSE Development
 
-The package is automatically submitted from the `master` branch to
-[system:install:head](https://build.opensuse.org/package/show/system:install:head/parti)
-OBS project. From that place it is forwarded to
-[openSUSE Factory](https://build.opensuse.org/project/show/openSUSE:Factory).
+To build, simply run `make`. Install with `make install`.
+
+Basically every new commit into the master branch of the repository will be auto-submitted
+to all current SUSE products. No further action is needed except accepting the pull request.
+
+Submissions are managed by a SUSE internal [jenkins](https://jenkins.io) node in the InstallTools tab.
+
+Each time a new commit is integrated into the master branch of the repository,
+a new submit request is created to the openSUSE Build Service. The devel project
+is [system:install:head](https://build.opensuse.org/package/show/system:install:head/parti).
+
+`*.changes` and version numbers are auto-generated from git commits, you don't have to worry about this.
+
+The spec file is maintained in the Build Service only. If you need to change it for the `master` branch,
+submit to the
+[devel project](https://build.opensuse.org/package/show/system:install:head/parti)
+in the build service directly.
+
+Development happens exclusively in the `master` branch. The branch is used for all current products.
 
-You can find more information about this workflow in the [linuxrc-devtools
+You can find more information about the changes auto-generation and the
+tools used for jenkis submissions in the [linuxrc-devtools
 documentation](https://github.com/openSUSE/linuxrc-devtools#opensuse-development).
 
 ## Example
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/parti-1.17/VERSION new/parti-1.18/VERSION
--- old/parti-1.17/VERSION	2018-04-25 15:37:55.000000000 +0200
+++ new/parti-1.18/VERSION	2018-04-26 16:05:19.000000000 +0200
@@ -1 +1 @@
-1.17
+1.18
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/parti-1.17/changelog new/parti-1.18/changelog
--- old/parti-1.17/changelog	2018-04-25 15:37:55.000000000 +0200
+++ new/parti-1.18/changelog	2018-04-26 16:05:19.000000000 +0200
@@ -1,41 +1,54 @@
+2018-04-26:	1.18
+	- merge gh#wfeldt/parti#9
+	- improve doc a bit
+	- update git2log script to latest version
+	- reference obs builds
+
 2018-04-25:	1.17
+	- merge gh#wfeldt/parti#8
 	- extended documentation
 
 2018-03-06:	1.16
+	- merge gh#wfeldt/parti#7
 	- Use standard location for isoinfo binary
 
-2017-09-08:	1.15
+2017-09-11:	1.15
+	- merge gh#wfeldt/parti#6
 	- show more details about extended partition links
-	- verbose now also shows for every partition where it is referenced (that is
 
-2017-03-31:	1.14
-	- update docs a bit
-	- code de-duplication
-	- re-arrange fat fs output a bit
+2017-04-03:	1.14
+	- merge gh#wfeldt/parti#4
 	- parse vfat super block
+	- re-arrange fat fs output a bit
+	- code de-duplication
+	- update docs a bit
 
-2015-10-12:	1.13
-	- show decoded gpt attribute bits
+2016-10-14:	1.13
+	- merge branch master
 
 2016-10-14:	1.12
+	- merge gh#wfeldt/parti#3
+	- show decoded gpt attribute bits
 	- added some GPT GUIDs of linux partitions
 
-2015-09-28:	1.11
+2015-10-12:	1.11
+	- merge branch master
+
+2015-10-07:	1.10
+	- merge gh#wfeldt/parti#2
 	- recognize prep partition type
 	- also show file system uuid
-
-2015-10-01:	1.10
-	- gitignore
-	- README: links to explain the information being handled
-	- Add link to linux-devtools documentation
 	- Convert README to Markdown
+	- Add link to linux-devtools documentation
+	- README: links to explain the information being handled
+	- gitignore
 
 2015-07-22:	1.9
 	- improved zipl parsing
 
 2015-07-17:	1.8
-	- support parsing zIPL on scsi devices
 	- fix endianness issues
+	- support parsing zIPL on scsi devices
 
 2014-10-20:	1.7
 	- show file name if partition refers to a file
@@ -53,20 +66,20 @@
 	- show file names in el-torito boot entries
 
 2014-10-16:	1.2
-	- added 'archive' Makefile target
-	- updated git2log script
 	- add bios boot partition type
+	- updated git2log script
+	- added 'archive' Makefile target
 
 2013-07-23:	1.1
-	- adjusted help text
-	- fixed Makefile
 	- added license and basic docs
+	- fixed Makefile
+	- adjusted help text
 
 2013-07-23:	1.0
-	- added log script
-	- fix Makefile
-	- rename to parti
-	- nicer
-	- add apple & el torito
 	- x
+	- add apple & el torito
+	- nicer
+	- rename to parti
+	- fix Makefile
+	- added log script
 
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/parti-1.17/git2log new/parti-1.18/git2log
--- old/parti-1.17/git2log	2018-04-25 15:37:55.000000000 +0200
+++ new/parti-1.18/git2log	2018-04-26 16:05:19.000000000 +0200
@@ -1,5 +1,16 @@
 #! /usr/bin/perl
 
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+#
+# This script is maintained at https://github.com/openSUSE/linuxrc-devtools
+#
+# If you're in another project, this is just a copy.
+# You may update it to the latest version from time to time...
+#
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+use strict;
+
 use Getopt::Long;
 
 use Data::Dumper;
@@ -8,198 +19,927 @@
 $Data::Dumper::Indent = 1;
 
 sub usage;
+sub changelog_outdated;
+sub get_github_project;
+sub get_version;
+sub get_tags;
+sub get_log;
+sub is_formatted_tag;
+sub get_branch;
+sub choose_tags;
+sub add_head_tag;
+sub tags_to_str;
+sub format_log;
+sub format_all_logs;
+sub fix_dates;
+sub add_line_breaks;
+sub format_date_obs;
+sub format_date_iso;
+sub raw_date_to_s;
 
 usage 0 if !@ARGV;
 
-@deps = qw ( .git/HEAD .git/refs/heads .git/refs/tags );
+my @changelog_deps = qw ( .git/HEAD .git/refs/heads .git/refs/tags );
+
+my $branch;
+my $current_version;
+my @tags;
+my @all_tags;
+my $config;
+
+my $opt_log;
+my $opt_version;
+my $opt_branch;
+my $opt_update;
+my $opt_file;
+my $opt_start;
+my $opt_max;
+my $opt_width = 66;
+my $opt_width_fuzz = 8;
+my $opt_sep_width = 68;
+my $opt_format = 'internal';		# obs, internal
+my $opt_merge_msg_before = 1;		# log auto generated pr merge message before the commit messages (vs. after)
+my $opt_join_author = 1;		# join consecutive commit messages as long as they are by the same author
+my $opt_keep_date = 1;			# don't join consecutive commit messages if they have different time stamps
+my $opt_default_email = 'opensuse-packaging@opensuse.org';	# default email to use in changelog
 
 GetOptions(
   'help'          => sub { usage 0 },
   'version'       => \$opt_version,
+  'branch'        => \$opt_branch,
   'update'        => \$opt_update,
+  'start=s'       => \$opt_start,
+  'format=s'      => \$opt_format,
+  'max=i'         => \$opt_max,
+  'width=i'       => \$opt_width,
+  'fuzz=i'        => \$opt_width_fuzz,
+  'merge-msg=s'   => sub { $opt_merge_msg_before = ($_[1] eq 'after' ? 0 : 1) },
+  'join-author!'  => \$opt_join_author,
+  'keep-date!'    => \$opt_keep_date,
   'log|changelog' => \$opt_log,
+  'default-email=s' => \$opt_default_email,
 ) || usage 1;
 
-usage 1 if @ARGV > 1 || !($opt_log || $opt_version);
+# ensure we are used correctly
+usage 1 if @ARGV > 1 || !($opt_log || $opt_version || $opt_branch);
 $opt_file = @ARGV ? shift : '-';
 
 die "no git repo\n" unless -d ".git";
 
-if($opt_update && $opt_file ne '-' && -f($opt_file)) {
-  $ok = 1;
+# if update option has been give write changelog only if git refs are newer
+exit 0 if $opt_update && $opt_file ne '-' && -f($opt_file) && !changelog_outdated($opt_file);
+
+$opt_max = 2 if $opt_version || $opt_branch;
 
-  $t = (stat $opt_file)[9];
+# gather some data
+get_github_project;
+get_branch;
+get_log;
+fix_dates;
+get_tags;
+choose_tags;
+add_head_tag;
+get_version;
+
+# just print current branch
+if($opt_branch) {
+  open my $f, ">$opt_file";
+  print $f $config->{branch} ? $config->{branch} : "master", "\n";
+  close $f;
+
+  exit 0;
+}
 
-  for (@deps) {
-    $ok = 0 if (stat)[9] > $t;
+# just print current version
+if($opt_version) {
+  my $old_version;
+
+  if($opt_file ne '-' && open(my $f, $opt_file)) {
+    chomp($old_version = <$f>);
+    close $f;
+  }
+
+  if($config->{version} ne $old_version) {
+    open my $f, ">$opt_file";
+    print $f "$config->{version}\n";
+    close $f;
   }
 
-  exit 0 if $ok;
+  exit 0;
 }
 
-for (`git branch`) {
-  if(/^\*\s+(\S+)/) {
-    $branch = $1;
-    last;
+# set start tag
+if($opt_start) {
+  my $x = is_formatted_tag $opt_start;
+  die "$opt_start: not a valid start tag\n" if !$x;
+  $x->{branch} = $config->{branch} if !$x->{branch};
+  $config->{start} = $x;
+}
+
+format_all_logs;
+
+open my $f, ">$opt_file";
+
+print $f $_->{formatted} for @{$config->{log}};
+
+close $f;
+
+exit 0;
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# usage(exit_code)
+#
+# Print help message and exit.
+# - exit_code: exit code
+#
+# Function does not return.
+#
+sub usage
+{
+  my $err = shift;
+
+  print <<"  usage";
+Usage: git2log [OPTIONS] [FILE]
+Create changelog and project version from git repo.
+  --changelog         Write changelog to FILE.
+  --version           Write version number to FILE.
+  --branch            Write current branch to FILE.
+  --start START_TAG   Start with tag START_TAG.
+  --max N             Write at most MAX long entries.
+  --update            Write changelog or version only if FILE is outdated.
+  --format FORMAT     Write log using FORMAT. Supported FORMATs are 'internal' (default) and 'obs'.
+  --width WIDTH       Reformat log entries to be max WIDTH chars wide.
+  --fuzz FUZZ         Allow log lines to be up to FUZZ chars longer as WIDTH to avoid
+                      line breaks leaving tiny bits on the last line.
+  --merge-msg WHERE   Log message about merges before or after the actual merge commit messages.
+                      Valid values for WHERE are 'after' and 'before' (default).
+  --join-author       Join consecutive commits as long as they are by the same author. (default)
+  --no-join-author    Keep consecutive commits by the same author separate.
+  --keep-date         Join consecutive commits only if they have the same date. (default)
+  --no-keep-date      Join consecutive commits even if dates differ.
+  --default-email     Use this email in changelog entries if no other suitable email could be
+                      determined (default: opensuse-packaging\@opensuse.org).
+  --help              Print this help text.
+  usage
+
+  exit $err;
+}
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# res = changelog_outdated(file)
+#
+# Return status of changelog file.
+# - file: changelog file name
+# - res: status
+#     1: file is newer than the last git repo change and should be updated
+#     0: file is still recent enough
+#
+# Relies on global var @changelog_deps.
+#
+sub changelog_outdated
+{
+  my $file = $_[0];
+
+  my $changelog_time = (stat $file)[9];
+
+  return 1 if !defined $changelog_time;
+
+  for (@changelog_deps) {
+    return 1 if (stat)[9] > $changelog_time;
+  }
+
+  return 0;
+}
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# get_github_project()
+#
+# Set $config->{github_project} to the github project name.
+#
+sub get_github_project
+{
+  if(`git config remote.origin.url` =~ m#github.com[:/]+(\S+/\S+)#) {
+    $config->{github_project} = $1;
+    $config->{github_project} =~ s/\.git$//;
   }
 }
 
-$branch = "master" if $branch eq '(no';
 
-die "no branch?\n" unless $branch;
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# get_version()
+#
+# Set $config->{branch} and $config->{version} to the current branch and
+# version info.
+#
+# This might be taken directly from HEAD if HEAD is tagged or otherwise be
+# exprapolated from the most recent tag (cf. add_head_tag()).
+#
+sub get_version
+{
+  $config->{version} = "0.0";
 
-# print STDERR "writing log for branch $branch\n";
+  my $tag = $config->{log}[0]{tags}[0];
 
-@tags = `git tag`;
+  if($tag->{version}) {
+    $config->{version} = $tag->{version};
+    $config->{branch} = $tag->{branch};
+  }
+}
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# get_tags()
+#
+# Parse $config->{raw_log}, extract tag names, and split into per-tag
+# sections.
+#
+# Only tags recognized by is_formatted_tag() are considered.
+#
+# The parsed logs is stored in $config->{log}, an array of log sections.
+# Each section is a hash with these keys:
+#   - 'tags': array of tags for this section
+#   - 'commit': git commit id associated with these tags
+#   - 'lines': git log lines
+#
+sub get_tags
+{
+  my $log_entry;
+
+  for (@{$config->{raw_log}}) {
+    if(/^commit (\S+)( \((.*)\))?/) {
+      my $commit = $1;
+      my $tag_list = $3;
+      my $xtag;
+
+      for my $t (split /, /, $tag_list) {
+        if($t =~ /tag: (\S+)/) {
+          my $tag = $1;
+          my $x = is_formatted_tag $tag;
+          push @$xtag, $x if $x;
+        }
+      }
 
-chomp @tags;
+      if($xtag) {
+        if($log_entry) {
+          push @{$config->{log}}, $log_entry;
+          last if $opt_max && @{$config->{log}} >= $opt_max;
+        }
+        $log_entry = { commit => $commit, tags => $xtag };
+      }
+      else {
+        $log_entry = { commit => $commit } if !$log_entry;
+      }
+    }
 
-for (@tags) {
-  if(/^\d/) {
-    s/(\d+)/sprintf "%04d", $1/eg;
-    push @ntags, $_;
+    push @{$log_entry->{lines}}, $_ if $log_entry;
   }
-  elsif(s/^$branch\-//) {
-    s/(\d+)/sprintf "%04d", $1/eg;
-    push @ntags, "$branch-$_";
+}
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# get_log()
+#
+# Read git log and store lines as array in $config->{raw_log} (trailing
+# newlines removed).
+#
+sub get_log
+{
+  chomp(@{$config->{raw_log}} = `git log --pretty=medium --date=raw --topo-order --decorate`);
+}
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# hash_ref = is_formatted_tag(tag_name)
+#
+# Parse tag and return hash ref with branch and version number parts or
+# undef if it doesn't match.
+# - tag_name: tag as string
+# - hash_ref: hash ref with internal tag representation (with keys 'branch' and 'version').
+#
+# This expects tags of the form "VERSION" or "BRANCH-VERSION" where VERSION
+# consists of decimal numbers separated by dots '.' and BRANCH can be any
+# string.
+# (Note: it doesn't really have to be the name of an existing branch.)
+#
+# Tags not conforming to this convention are ignored.
+#
+sub is_formatted_tag
+{
+  if($_[0] =~ /^((.+)-)?((\d+\.)*\d+)$/) {
+    return { branch => $2, version => $3 }
   }
+
+  return undef;
+}
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# get_branch()
+#
+# Get currently active git branch and store in $config->{branch}.
+#
+# 'master' branch is represented by empty 'branch' key.
+#
+sub get_branch
+{
+  chomp(my $branch = `git rev-parse --abbrev-ref HEAD`);
+
+  $branch = "" if $branch eq 'master';
+
+  $config->{branch} = $branch;
 }
 
-@tags = sort @ntags;
 
-die "no tags at all?\n" unless @tags;
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# res = tag_sort(a, b)
+#
+# Compare 2 tags.
+# - a, b: refs to tag hash
+# - res: -1, 0, 1
+#
+# This is used when we have to decide between alternative tags.
+# (Prefer 'lesser' variant.)
+#
+sub tag_sort
+{
+  my ($x, $y);
+
+  $x = length $a->{version};
+  $y = length $b->{version};
 
-$current_version = $tags[-1];
-$current_version =~ s/(\d+)/$1 + 0/eg;
+  # longer version number first
+  return $y <=> $x if $y <=> $x;
 
-if(`git log --pretty=medium --date=iso '$current_version..HEAD'`) {
-  $current_version =~ s/(\d+)$/$1 + 1/e;
+  return $a->{branch} cmp $b->{branch};
 }
 
-$current_version =~ s/^$branch\-//;
 
-if($opt_version) {
-  open F, ">$opt_file";
-  print F "$current_version\n";
-  close F;
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# str = tag_to_str(tag_ref)
+#
+# Convert tag into string.
+# - tag_ref: ref to hash with 'branch' and 'version' keys
+# - str: string (e.g. "foo-1.44")
+#
+# 'master' branch is represented by missing/empty 'branch' key.
+#
+sub tag_to_str
+{
+  my $tag = $_[0];
+  my $str;
 
-  exit 0;
+  $str = "$tag->{branch}-" if $tag->{branch} ne "";
+  $str .= $tag->{version};
+
+  return $str;
+}
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# str = tags_to_str(tag_array_ref)
+#
+# Convert array of tags into string.
+# - tag_array_ref: ref to array of tags
+# - str: string (e.g. "(tag1, tag2)"
+#
+# This function is used only internally for debugging.
+#
+sub tags_to_str
+{
+  my $tags = $_[0];
+  my $str;
+
+  for my $t (@$tags) {
+    $str .= ", " if $str;
+    $str .= tag_to_str $t;
+  }
+
+  return "($str)";
 }
 
-if($branch ne 'master') {
-  for ($i = 0; $i < @tags; $i++) {
-    if($tags[$i] =~ /^$branch\-(\S+)/) {
-      $i2 = $i;
-      $bi = $1;
-      last;
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# choose_tags()
+#
+# Scan commit messages and extract tag & branch information.
+#
+# This stores the tag/branch info in $config->{log}[]{tags}.
+#
+sub choose_tags
+{
+  my $branch = $config->{branch};
+
+  for my $x (@{$config->{log}}) {
+    # printf "# %s\n", tags_to_str($x->{tags});
+
+    # no tag info? -> ignore
+    next if !$x->{tags};
+
+    # single tag? -> remember branch info
+    if(@{$x->{tags}} == 1) {
+      $branch = $x->{tags}[0]{branch};
+      next;
     }
+
+    # several tags? -> choose one
+
+    # any with current branch name?
+    my @t = grep { $_->{branch} eq $branch } @{$x->{tags}};
+
+    # no? -> choose among all
+    @t = @{$x->{tags}} if @t == 0;
+
+    # prefer longest version number, then alphanumerically smallest branch name
+    @t = sort tag_sort @t;
+
+    $branch = $t[0]{branch};
+    $x->{tags} = [ $t[0] ];
+
+    # printf "X %s\n", tags_to_str($x->{tags});
   }
+}
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# add_head_tag()
+#
+# Suggest tag for HEAD if there isn't one.
+#
+# Basically, use branch + version from most recent tag and increment version.
+#
+sub add_head_tag
+{
+  return if @{$config->{log}} < 2;
 
-  # print STDERR ">> $branch-$bi\n";
+  # HEAD tagged already?
+  return if $config->{log}[0]{tags};
 
-  warn "no tags in this branch yet\n" unless $bi;
+  # the first tagged commit if HEAD isn't tagged
+  my $tag = { %{$config->{log}[1]{tags}[0]} };
 
-  for ($i = 0; $i < $i2; $i++) {
-    if($tags[$i] ge $bi) {
-      if($tags[$i] eq $bi) {
-        $i1 = $i;
+  # increment version
+  $tag->{version} =~ s/(\d+)$/$1 + 1/e;
+
+  $config->{log}[0]{tags}[0] = $tag;
+
+  # remember that the tag was generated
+  $config->{log}[0]{was_untagged} = 1;
+}
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# fix_dates()
+#
+# Adjust time stamps in entire git log.
+#
+# The time stamps of the git commits are not necessarily ordered by date.
+# But the generated changelog is required to have a strictly monotonic time.
+#
+# We do this by going through the log in reverse and rewriting any dates we
+# find whenever the date decreases.
+#
+# A minimum time difference of 1 second beween entries is maintained.
+#
+# Not very subtle but it works.
+#
+sub fix_dates
+{
+  my $last_date;
+
+  for (reverse @{$config->{raw_log}}) {
+    # e.g. "Date: 1443184889 +0200"
+    if(/^(Date:\s+)(\S+)(\s+\S+)/) {
+      if(defined $last_date && $2 < $last_date) {
+        $_ = "$1$last_date$3\n";
       }
-      elsif($i > 0) {
-        $i1 = $i - 1;
+      else {
+        $last_date = $2;
       }
-      last;
+
+      # ensure a minimal time gap of 1 second
+      $last_date += 1;
     }
   }
+}
+
 
-  splice @tags, $i1, $i2 - $i1;
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# format_all_logs()
+#
+# Format the entire git log.
+#
+# This is done for every code version individually (the log has already been
+# split accordingly).
+#
+# If $config->{start} is set, use this as starting point. Else format the
+# entire git log.
+#
+sub format_all_logs
+{
+  # check if start tag actually exists - if not, print nothing
+  if($config->{start}) {
+    my $tag_found;
+    for (@{$config->{log}}) {
+      $tag_found = 1, last if grep { tag_to_str($config->{start}) eq tag_to_str($_) } @{$_->{tags}};
+    }
+    return if !$tag_found;
+  }
+
+  for (@{$config->{log}}) {
+    if($config->{start}) {
+      # stop if we meet the start tag
+      last if grep { tag_to_str($config->{start}) eq tag_to_str($_) } @{$_->{tags}};
+    }
+    format_log $_;
+  }
 }
 
-map { s/(\d+)/$1 + 0/eg } @tags;
 
-push @tags, "HEAD";
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# format_log(log)
+#
+# Format log messages.
+# - log: is an array ref with individual commits
+#
+# All commits belong to a specific code version (stored in $log->{tag}).
+# $log->{formatted} holds the result.
+#
+# The process is done in several individual steps, documented below in the code.
+#
+sub format_log
+{
+  my $log = $_[0];
+
+  my $merge;
+  my $commit;
+  my $saved_commit;
+  my $commits;
+
+  for (@{$log->{lines}}) {
+    if(/^commit (\S+)/) {
+      $commit = { ref => $1 };
+      push @{$commits}, $commit;
+
+      if(
+        $merge &&
+        $merge->{merge_end} eq substr($commit->{ref}, 0, length($merge->{merge_end}))
+      ) {
+        undef $merge;
+      }
+
+      if($merge) {
+        $commit->{merge_ref} = $merge->{ref};
+        $commit->{date} = $merge->{date};
+        # add to all commits so it's not lost when we re-arrange
+        $commit->{merge_msg} = $merge->{msg} if $merge->{msg};
+        # saved entry no longer needed
+        undef $saved_commit;
+      }
+
+      next;
+    }
+
+    if(/^Merge: (\S+)/) {
+      if($commit) {
+        $merge = { merge_end => $1, ref => $commit->{ref} } unless $merge;
+        $saved_commit = pop @{$commits};
+      }
+      undef $commit;
+      next;
+    }
+
+    if(/^Date:\s+(\S.*)/) {
+      if($commit) {
+        $commit->{date} = $1 if !$commit->{date};
+      }
+      elsif($merge) {
+        $merge->{date} = $1 if !$merge->{date};
+      }
+      next;
+    }
+
+    if(/^Author:\s+(\S.*)/) {
+      $commit->{author} = $1 if $commit;
+      $merge->{author} = $1 if $merge && !$merge->{author};
+      next;
+    }
+
+    if($commit) {
+      push @{$commit->{lines}}, $_ if s/^    //;
+    }
+    elsif($merge && !$merge->{msg}) {
+      if(/^    Merge pull request (#\d+) from (\S+)/) {
+        if($config->{github_project}) {
+          $merge->{msg} = "merge gh#$config->{github_project}$1";
+        }
+        else {
+          $merge->{msg} = "merge pr $2";
+        }
+      }
+      elsif(/^    Merge branch '([^']+)'/) {
+        $merge->{msg} = "merge branch $1";
+      }
+    }
+  }
+
+  # it can happen that there's a lonely merge commit left at the end
+  if($merge && $saved_commit) {
+    $saved_commit->{merge_ref} = $merge->{ref};
+    $saved_commit->{date} = $merge->{date};
+    $saved_commit->{author} = $merge->{author};
+    $saved_commit->{merge_msg} = $merge->{msg} if $merge->{msg};
+    $saved_commit->{formatted} = [];
+
+    push @{$commits}, $saved_commit;
+  }
+
+  # Note: the individual steps below work on the array @$commits and modify
+  # its content.
+
+  # step 1
+  # - if there are paragraphs starting with '@log@' or '@+log@'
+  #     - delete first paragraph (short summary)
+  # - else
+  #     - keep only first paragraph
+  # - if there is a paragraph starting with '@-log', delete entire log
+  # - tag commits that have a '@log@' tag so we can delete untagged commits
+  #   belonging to the same merge commit later
+
+  my $tagged_merges = {};
+
+  for my $commit (@$commits) {
+    my $para_cnt = 0;
+    my $delete_all = 0;
+    my $delete_first = 0;
+    for (@{$commit->{lines}}) {
+      $para_cnt++ if $_ eq "";
+      $para_cnt = 0, $delete_first = 1 if /^\@\+log\@/;
+      $delete_all = 1 if /^\@\-log\@/;
+      if(/^\@log\@/) {
+        $para_cnt = 0;
+        $commit->{clear} = 1;
+        $tagged_merges->{$commit->{merge_ref}} = 1 if $commit->{merge_ref} || $log->{was_untagged};
+      }
+      $_ = undef if $para_cnt;
+    }
+    shift @{$commit->{lines}} if $delete_first;
+    $commit->{lines} = [] if $delete_all;
+  }
 
-# print Dumper(\@tags);
+  # step 2
+  # - clean up tagged commits or commits belonging to tagged merges
 
-open F, ">$opt_file";
+  for my $commit (@$commits) {
+    next unless $commit->{clear} || $tagged_merges->{$commit->{merge_ref}};
+    for (@{$commit->{lines}}) {
+      last if /^\@\+?log\@/;
+      $_ = undef;
+    }
+  }
 
-for ($i = @tags - 1; $i > 0; $i--) {
-  $date = undef;
-  @t = `git log --pretty=medium --date=iso '$tags[$i-1]..$tags[$i]'`;
+  # step 3
+  # - join lines
 
-  # print "\n--- $tags[$i-1]..$tags[$i] ---\n", @t, "---\n";
+  for my $commit (@$commits) {
+    my $lines;
+    my $line;
+
+    for (@{$commit->{lines}}) {
+      next if $_ eq "";
+      if(
+        s/^\s*[+\-][\-\s]*// ||
+        s/^\@\+?log\@// ||
+        $line eq ""
+      ) {
+        s/^\s*//;
+        push @$lines, $line if $line ne "";
+        $line = $_;
+      }
+      else {
+        s/^\s*//;
+        $line .= " " if $line ne "";
+        $line .= $_;
+      }
+    }
+    push @$lines, $line if $line ne "";
 
-  undef @t2;
-  $merge = 0;
-  for (@t) {
-    $merge = 1 if /^Merge: /;
-    $merge = 0 if /^commit /;
-    push @t2, $_ if !$merge;
+    $commit->{formatted} = $lines if $lines;
   }
-  @t = @t2;
 
-  undef @t2;
-  $detail = 0;
-  for (@t) {
-    $detail = 1 if /^    $/;
-    $detail = 0 if /^commit /;
-    if($detail && /^    [^\-\s]/) {
-      # push @t2, "# $_";
+  # step 4
+  # - fix small glitches
+
+  for my $commit (@$commits) {
+    next unless $commit->{formatted};
+    for (@{$commit->{formatted}}) {
+      s/(fate|bnc|bsc)\s*(#\d+)/\L$1\E$2/ig;
+    }
+  }
+
+  # step 5
+  # - add merge info at the top or bottom (depending on $opt_merge_msg_before)
+
+  my $merge_logged;
+
+  for my $commit ($opt_merge_msg_before ? reverse(@$commits) : @$commits) {
+    next unless $commit->{formatted};
+
+    if($commit->{merge_ref} && !$merge_logged->{$commit->{merge_ref}}) {
+      $merge_logged->{$commit->{merge_ref}} = 1;
+      if($commit->{merge_msg}) {
+        if($opt_merge_msg_before) {
+          unshift @{$commit->{formatted}}, $commit->{merge_msg};
+        }
+        else {
+          push @{$commit->{formatted}}, $commit->{merge_msg};
+        }
+      }
+    }
+  }
+
+  # step 6
+  # - join commit messages with same author (optionally even with different dates)
+
+  my $commit0;
+
+  for my $commit (@$commits) {
+    next if !$commit->{formatted};
+    $commit0 = $commit, next if !$commit0;
+
+    if(
+      # $commit->{merge_ref} eq $commit0->{merge_ref} &&
+      (
+        $opt_join_author && ($commit->{author} eq $commit0->{author})
+        && (!$opt_keep_date || $commit->{date} eq $commit0->{date})
+      )
+      || $opt_format eq 'internal'
+    ) {
+      unshift @{$commit0->{formatted}}, @{$commit->{formatted}};
+      delete $commit->{formatted};
+    }
+    else {
+      $commit0 = $commit;
+    }
+  }
+
+  # step 7
+  # - add version tag at the end of the first log entry
+
+  for my $commit (@$commits) {
+    next unless $commit->{formatted};
+
+    if($opt_format eq 'obs') {
+      push @{$commit->{formatted}}, $log->{tags}[0]{version} if defined $log->{tags}[0]{version};
     }
     else {
-      push @t2, $_;
+      # push @{$commit->{formatted}}, tag_to_str($log->{tags}[0]);
     }
+
+    last;
   }
-  @t = @t2;
 
-  # print "\n--- $tags[$i-1]..$tags[$i] ---\n", @t;
+  # step 8
+  # - add line breaks
 
-  chomp @t;
-  for (@t) {
-    if(/^Date:\s*(\S+)/) {
-      $date = $1;
-      last;
+  for my $commit (@$commits) {
+    next unless $commit->{formatted};
+    for (@{$commit->{formatted}}) {
+      $_ = add_line_breaks $_;
     }
   }
-  @t = grep { !/^(commit|Author:|Date:|Merge:|\s*$)|created.*tag/ } @t;
-  if(@t) {
-    # rewrite a bit to have it look more consistent
-    map { s/(fate|bnc)#/$1 #/g } @t;
-    map { s/\(#/(bnc #/g } @t;
-    map { s/bug\s*#/bnc #/g } @t;
-    map { s/feat(\.|ure)?\s*#?(\d+)/fate #$2/g } @t;
-    map { s/^ {4}// } @t;
-    map { s/^ {8}// } @t;
-    map { s/^ +/  / } @t;
-    map { s/^\s*[+\-][\-\s]*/- / } @t;
-    map { s/^([^ \-])/- $1/ } @t;
-    map { s/^/\t/ } @t;
-    map { s/\\'/'/ } @t;
 
-#    print "\n--- $tags[$i-1]..$tags[$i] ---\n", join("\n", @t);
+  # step 9
+  # - generate final log message
+  #
+  # note: non-(open)suse email addresses are replaced by $opt_default_email
+
+  my $formated_log;
+
+  for my $commit (@$commits) {
+    next unless $commit->{formatted} && @{$commit->{formatted}};
+
+    if($opt_format eq 'obs') {
+      $formated_log .= "-" x $opt_sep_width . "\n";
+      $formated_log .= format_date_obs($commit->{date});
+    }
+    else {
+      $formated_log .= format_date_iso($commit->{date});
+    }
+    if($opt_format eq 'obs') {
+      my $auth = $commit->{author};
+      $auth =~ s/^.*.*$//;
+      # replace non-suse e-mail addresses with a generic one
+      if($auth !~ /\@(suse\.(com|cz|de)|opensuse\.org)$/) {
+        $auth = $opt_default_email;
+      }
+      $formated_log .= " - $auth\n\n";
+    }
+    else {
+      $formated_log .= ":\t" . tag_to_str($log->{tags}[0]) . "\n";
+    }
+
+    for (@{$commit->{formatted}}) {
+      s/^/\t/mg if $opt_format eq 'internal';
+      $formated_log .= "$_\n";
+    }
 
-    $t = $tags[$i];
-    $t = "${branch}-$t" if $branch ne 'master' && $t eq "HEAD";
-    $t =~ s/HEAD/$current_version/;
-    print F "$date:\t$t\n";
-    print F join("\n", @t), "\n\n";
+    $formated_log .= "\n";
   }
+
+  $log->{formatted} = $formated_log;
 }
 
-close F;
 
-sub usage
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# new_text = add_line_breaks(text)
+#
+# Add line breaks to text.
+# - text: some text
+# - new_text: same text, reformatted
+#
+# Lines are formatted to have a maximal length of $opt_width. If this causes
+# the last line to be shorter than $opt_width_fuzz, it is appended to the
+# previous line.
+#
+sub add_line_breaks
 {
-  my $err = shift;
+  my @words = split /\s+/, @_[0];
+  my $remaining_len = length(join '', @words);
 
-  print <<"  usage";
-Usage: git2log [OPTIONS] [FILE]
-Create changelog and project version from git repo.
-  --changelog   Write changelog to FILE.
-  --version     Write version number to FILE.
-  --update      Write changelog or version only if FILE is outdated.
-  --help        Print this help text.
-  usage
+  my $str = shift(@words);
+  my $len = length $str;
 
-  exit $err;
+  my $next_len;
+  my $word_len;
+
+  for (@words) {
+    $word_len = length;
+    $remaining_len -= $word_len;
+    $next_len = $len + $word_len + 1;
+    if(
+      $next_len >= $opt_width &&
+      $next_len + $remaining_len + 1 >= $opt_width + $opt_width_fuzz
+    ) {
+      $str .= "\n  $_";
+      $len = $word_len;
+    }
+    else {
+      $str .= " $_";
+      $len += $word_len + 1;
+    }
+  }
+
+  return "- " . $str;
 }
 
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# seconds = raw_date_to_s(git_date)
+#
+# Convert git raw date to seconds.
+# - git_date: raw git format (e.g. "1443184889 +0200")
+# - seconds: the seconds part (e.g. "1443184889")
+#
+sub raw_date_to_s
+{
+  return (split / /, $_[0])[0];
+}
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# date = format_date_obs(git_date)
+#
+# Convert git raw date to obs format.
+# - git_date: raw git format (e.g. "1443184889 +0200")
+# - date: obs format ("Fri Sep 25 12:41:29 UTC 2015")
+#
+sub format_date_obs
+{
+  my @d = gmtime(raw_date_to_s($_[0]));
+
+  return
+    qw(Sun Mon Tue Wed Thu Fri Sat)[$d[6]] . " " .
+    qw(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec)[$d[4]] . " " .
+    $d[3] . " " .
+    sprintf("%02d:%02d:%02d", $d[2], $d[1], $d[0]) . " UTC " .
+    (1900 + $d[5]);
+}
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+# date = format_date_iso(git_date)
+#
+# Convert git raw date to iso format.
+# - git_date: raw git format (e.g. "1443184889 +0200")
+# - date: obs format ("2015-09-25")
+#
+sub format_date_iso
+{
+  my @d = gmtime(raw_date_to_s($_[0]));
+
+  return sprintf("%04d-%02d-%02d", 1900 + $d[5], $d[4] + 1, $d[3]);
+}

    

commit parti for openSUSE:Factory

root＠hilbert.suse.de