File _service:obs_scm:obs-service-set_version-0.5.6.... of Package obs-service-set_version

Overview Repositories Revisions Requests Users Attributes Meta

File _service:obs_scm:obs-service-set_version-0.5.6.obscpio of Package obs-service-set_version (Revision ffd782ba6f886d750b308f565e73ce36)

Currently displaying revision ffd782ba6f886d750b308f565e73ce36 , Show latest

07070108494195000081A4000000020000000200000001595A67C40000000D000000FE0000002100000000000000000000003300000000obs-service-set_version-0.5.6/debian/source/format3.0 (native)
07070108494194000041ED000000020000000200000002595A67C400000000000000FE0000002100000000000000000000002C00000000obs-service-set_version-0.5.6/debian/source070701048D573C000081A4000000020000000200000001595A67C400000210000000FE0000002100000000000000000000002F00000000obs-service-set_version-0.5.6/debian/changelogobs-service-set-version (0.4.2) unstable; urgency=low

* the extension needs to be \.
  * test with defined() at ./set_version line 118.
  * Fix processing of --file parameter
  * Add support for setting the version in debian.changelog
  * Sort local file list based on modification time (newest first)

-- Jan Blunck <jblunck@infradead.org>  Wed, 10 Sep 2014 18:20:20 +0200

obs-service-set-version (0.4.1) unstable; urgency=low

* Initial release

-- Daniel Gollub <dgollub@brocade.com>  Thu, 03 Jul 2014 09:04:52 +0200
070701048E5804000081A4000000020000000200000001595A67C400000002000000FE0000002100000000000000000000002C00000000obs-service-set_version-0.5.6/debian/compat8
070701048E580C000081A4000000020000000200000001595A67C400000229000000FE0000002100000000000000000000002D00000000obs-service-set_version-0.5.6/debian/controlSource: obs-service-set-version
Section: devel
Priority: extra
Maintainer: Daniel Gollub <dgollub@brocade.com>
Build-Depends: debhelper (>= 8.0.0)
Standards-Version: 3.9.3
Homepage: https://github.com/openSUSE/obs-service-set_version

Package: obs-service-set-version
Architecture: all
Depends: ${misc:Depends}, sed
Description: An OBS source service: Update spec file version
 This is a source service for openSUSE Build Service.
 Very simply script to update the version in .spec or .dsc files according to
 a given version or to the existing files.

070701048E5C68000081A4000000020000000200000001595A67C40000045F000000FE0000002100000000000000000000002F00000000obs-service-set_version-0.5.6/debian/copyrightFormat: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
Upstream-Name: obs-service-set_version
Source: https://github.com/openSUSE/obs-service-set_version

Files: *
Copyright: 2010 Adrian Schröter <adrian@suse.de>
License: GPL-2.0+

Files: debian/*
Copyright: 2014 Daniel Gollub <dgollub@brocade.com>
License: GPL-2.0+

License: GPL-2.0+
 This package 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 package 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 <http://www.gnu.org/licenses/>
 .
 On Debian systems, the complete text of the GNU General
 Public License version 2 can be found in "/usr/share/common-licenses/GPL-2".
070701048E5C78000081ED000000020000000200000001595A67C400000048000000FE0000002100000000000000000000002B00000000obs-service-set_version-0.5.6/debian/rules#!/usr/bin/make -f
# -*- makefile -*-
#
export DH_VERBOSE=1

%:
	dh $@ 
0707010C78E289000081A4000000020000000200000001595A67C400000095000000FE0000002100000000000000000000004400000000obs-service-set_version-0.5.6/tests/data_test_from_commandline.json[
  [
    "1.2.3", "1"
  ],
  [
    "1.2.3", "3.4.5"
  ],
  [
    "1.2.3~456+789-Devel3", "3.4.5"
  ],
  [
    "3.4.5", "1.2.3~456+789-Devel3"
  ]
]
0707010C78E28A000081A4000000020000000200000001595A67C40000004C000000FE0000002100000000000000000000005800000000obs-service-set_version-0.5.6/tests/data_test_from_commandline_with_multiple_files.json[
  [
    {"Version": "4.5.6"}, "1",
    ["test1.spec", "test2.spec"]
  ]
]
0707010C78E28B000081A4000000020000000200000001595A67C400000151000000FE0000002100000000000000000000005500000000obs-service-set_version-0.5.6/tests/data_test_from_commandline_with_single_file.json[
  [
    {"Version": "4.5.6"}, "1",
    "test1.spec", ["test2.spec"]
  ],
  [
    {"Version": "1.2.3"}, "3.4.5",
    "test1.spec", ["test2.spec"]
  ],
  [
    {"Version": "1.2.3~456+789-Devel3"}, "3.4.5",
    "test1.spec", ["test2.spec"]
  ],
  [
    {"Version": "3.4.5"}, "1.2.3~456+789-Devel3",
    "test1.spec", ["test2.spec"]
  ]
]
0707010C78E28C000081A4000000020000000200000001595A67C4000000E4000000FE0000002100000000000000000000004E00000000obs-service-set_version-0.5.6/tests/data_test_from_tarball_with_basename.json[
  ["testprog-1.2.3.tar", [], "1.2.3"],
  ["testprog-1.2.3.tar", ["xyz-4.5.6"], "1.2.3"],
  ["helloworld-1.2.3.tar", ["testprog-4.5.6"], "4.5.6"],
  ["helloworld-1.2.3.tar", ["testprog-4.5.6", "another-testprog-7"], "4.5.6"]
]
0707010C78E28D000081A4000000020000000200000001595A67C400000294000000FE0000002100000000000000000000006200000000obs-service-set_version-0.5.6/tests/data_test_from_tarball_with_basename_with_multiple_files.json[
  [
    "testprog-1.2.3.tar", [],
    "1.2.3",
    [
      "test1.spec", "test2.spec",
      "1.debian.changelog", "2.debian.changelog"
    ]
  ],
  [
    "testprog-1.2.3.tar", ["xyz-4.5.6"],
    "1.2.3",
    [
      "test1.spec", "test2.spec",
      "1.debian.changelog", "2.debian.changelog"
    ]
  ],
  [
    "helloworld-1.2.3.tar", ["testprog-4.5.6"],
    "4.5.6",
    [
      "test1.spec", "test2.spec",
      "1.debian.changelog", "2.debian.changelog"
    ]
  ],
  [
    "helloworld-1.2.3.tar", ["testprog-4.5.6", "another-testprog-7"],
    "4.5.6",
    [
      "test1.spec", "test2.spec",
      "1.debian.changelog", "2.debian.changelog"
    ]
  ]
]
0707010C78E28E000081A4000000020000000200000001595A67C4000001C4000000FE0000002100000000000000000000005100000000obs-service-set_version-0.5.6/tests/data_test_from_tarball_with_single_file.json[
  ["testprog-1.2.3.tar", [], "8.8.8", "1.2.3"],
  ["testprog-1.2.3.tar", ["testprog-4.5.6"], "8.8.8", "4.5.6"],
  ["tetsprog-2015.10.tar", [], "8.8.8", "2015.10"],
  ["testprog-512.tar", [], "8.8.8", "512"],
  ["1.2.3.tar", ["testprog-4.5.6"], "8.8.8", "4.5.6"],
  ["testprog-master.tar", ["testprog-4.5.6"], "8.8.8", "4.5.6"],
  ["testprog-master.tar", ["testprog-4.5.6"], " ", "4.5.6"],
  ["testprog-master.tar", ["testprog-4.5.6"], "", "4.5.6"]
]
0707010C78E297000081A4000000020000000200000001595A67C400002292000000FE0000002100000000000000000000003100000000obs-service-set_version-0.5.6/tests/test_base.py# Copyright (C) 2015 SUSE Linux GmbH
#
# 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, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,USA.

import imp
import os
import re
import shutil
import subprocess
import sys
import tarfile
import tempfile
import unittest

from ddt import data, ddt, unpack

# NOTE(toabctl): Hack to import non-module file for testing
sv = imp.load_source("set_version", "set_version")

SET_VERSION_EXECUTABLE = os.path.abspath(
    os.path.join(os.path.dirname(__file__), '../', 'set_version')
)

class SetVersionBaseTest(unittest.TestCase):
    """Basic test class. Other tests should use this one"""

def setUp(self):
        self._tmpdir = tempfile.mkdtemp(prefix='obs-service-set_version-test-')
        os.chdir(self._tmpdir)

def __file_contains_string(self, file_path, string):
        with open(file_path, "r") as f:
            content = f.read()
        m = re.search(re.escape(string), content)
        return (m is not None, content)

def _check_file_assert_contains(self, file_path, string):
        contains, content = self.__file_contains_string(file_path, string)
        err_msg = "%s doesn't contain match of %s. " \
                  "Content is:\n#####\n%s#####" % (
                      file_path, string, content)
        self.assertTrue(contains,
                        err_msg)

def _check_file_assert_not_contains(self, file_path, string):
        contains, content = self.__file_contains_string(file_path, string)
        err_msg = "%s contain match of %s. " \
                  "Content is:\n#####\n%s#####" % (
                      file_path, string, content)
        self.assertFalse(contains,
                         err_msg)

def _write_tarfile(self, tar_name, tar_dirs, tar_files):
        """write a tarfile with the given dirs and given files"""
        tar_path = os.path.join(self._tmpdir, tar_name)
        with tarfile.open(tar_path, "w") as t:
            for d in tar_dirs:
                td = tarfile.TarInfo(d)
                td.type = tarfile.DIRTYPE
                t.addfile(td)
            for f in tar_files:
                td = tarfile.TarInfo(f)
                t.addfile(td)
        return tar_path

def _run_set_version(self, params=[]):
        self._tmpoutdir = tempfile.mkdtemp(
            prefix='obs-service-set_version-test-outdir-')
        cmd = [sys.executable,
               SET_VERSION_EXECUTABLE,
               '--outdir', self._tmpoutdir] + params
        try:
            subprocess.check_output(
                cmd, stderr=subprocess.STDOUT, env=os.environ.copy())
            for f in os.listdir(self._tmpoutdir):
                os.unlink(self._tmpdir+"/"+f)
                # FIXME: in most modes the files get not replaced,
                # but store in parallel with _service: prefix
                shutil.move(self._tmpoutdir+"/"+f, self._tmpdir)
            shutil.rmtree(self._tmpoutdir)
        except subprocess.CalledProcessError as e:
            raise Exception(
                "Can not call '%s' in dir '%s'. Error: %s" % ("".join(cmd),
                                                              self._tmpdir,
                                                              e.output))

def tearDown(self):
        shutil.rmtree(self._tmpdir)

@ddt
class TestSetVersionBasics(SetVersionBaseTest):
    @data(
        (
            ["%define version_unconverted 1.2.3"],
            ["%define version_unconverted 4.5.6"],
            "version_unconverted", "4.5.6"
        ),
        (
            ["%define version_unconverted     1.2.3"],
            ["%define version_unconverted     4.5.6"],
            "version_unconverted", "4.5.6"
        ),
        (
            ["Hi foo", "%define version_unconverted 1.2.3", "Ho bar"],
            ["Hi foo", "%define version_unconverted 4.5.6", "Ho bar"],
            "version_unconverted", "4.5.6"
        ),
        (
            [
                "%define foodef bar",
                "%define version_unconverted 1.2.3",
                "%define bardef foo"
            ],
            [
                "%define foodef bar",
                "%define version_unconverted 4.5.6",
                "%define bardef foo"
            ],
            "version_unconverted", "4.5.6"
        )
    )
    @unpack
    def test_replace_define_replace(self, lines, expected_lines,
                                    define_name, define_value):
        fn = os.path.join(self._tmpdir, "test-file")
        with open(fn, "w") as f:
            f.write("\n".join(lines))
        # do the replacement
        sv._replace_define(os.path.basename(fn),
                           define_name, define_value)
        # check
        with open(fn, "r") as f:
            current_lines = f.read().split("\n")
            self.assertEqual(len(current_lines), len(expected_lines))
            for nbr, l in enumerate(current_lines):
                self.assertEqual(l, expected_lines[nbr])

@data(
        (
            ["Name: foobar"],
            ["%define version_unconverted 4.5.6", "", "Name: foobar"],
            "version_unconverted", "4.5.6"
        ),
        (
            ["Name: foobar"],
            ["%define version_unconverted 4.5.6", "", "Name: foobar"],
            "version_unconverted", "4.5.6"
        ),
        (
            ["AnyTag: ha", "Name: foo"],
            [
                "AnyTag: ha",
                "%define version_unconverted 4.5.6",
                "",
                "Name: foo"
            ],
            "version_unconverted", "4.5.6"
        ),
        (
            ["Name: foobar", "Version: 1.2.3"],
            [
                "%define version_unconverted 4.5.6",
                "",
                "Name: foobar",
                "Version: 1.2.3"
            ],
            "version_unconverted", "4.5.6"
        )
    )
    @unpack
    def test_replace_define_add(self, lines, expected_lines,
                                define_name, define_value):
        fn = os.path.join(self._tmpdir, "test-file")
        with open(fn, "w") as f:
            f.write("\n".join(lines))
        # do the addition
        sv._replace_define(os.path.basename(fn),
                           define_name, define_value)
        # check
        with open(fn, "r") as f:
            current_lines = f.read().split("\n")
            self.assertEqual(len(current_lines), len(expected_lines))
            for nbr, l in enumerate(current_lines):
                self.assertEqual(l, expected_lines[nbr])

@data(
        (
            ["%setup -q -n %{component}-%{version}"],
            ["%setup -q -n %{component}-%{version_unconverted}"],
        ),
        (
            ["%setup -q -n %{component}-1.2.3"],
            ["%setup -q -n %{component}-1.2.3"],
        ),
        (
            ["%setup -q -n foobar-%{version}"],
            ["%setup -q -n foobar-%{version_unconverted}"],
        ),
        (
            ["%setup -q -n foobar-%{version}-bar"],
            ["%setup -q -n foobar-%{version_unconverted}-bar"],
        ),
        (
            ["foo", "%setup -q -n %{component}-%{version}", "bar"],
            ["foo", "%setup -q -n %{component}-%{version_unconverted}", "bar"],
        ),
        (
            ["foo", "%setup -q -n %{component}-%{version}", "bar"],
            ["foo", "%setup -q -n %{component}-%{version_unconverted}", "bar"],
        ),
        (
            ["foo", "%setup -q", "bar"],
            ["foo", "%setup -q -n %{name}-%{version_unconverted}", "bar"],
        ),
        (
            ["foo", "%setup", "bar"],
            ["foo", "%setup  -n %{name}-%{version_unconverted}", "bar"],
        )
    )
    @unpack
    def test_replace_spec_setup(self, lines, expected_lines):
        fn = os.path.join(self._tmpdir, "test-file")
        with open(fn, "w") as f:
            f.write("\n".join(lines))
        # do the replacement
        sv._replace_spec_setup(os.path.basename(fn), "version_unconverted")
        # check
        with open(fn, "r") as f:
            current_lines = f.read().split("\n")
            self.assertEqual(len(current_lines), len(expected_lines))
            for nbr, l in enumerate(current_lines):
                self.assertEqual(l, expected_lines[nbr])
0707010C78E2AD000081A4000000020000000200000001595A67C4000010A5000000FE0000002100000000000000000000003C00000000obs-service-set_version-0.5.6/tests/test_debianchangelog.py# Copyright (C) 2015 SUSE Linux GmbH
#
# 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, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,USA.

import os
import subprocess
import unittest

from ddt import ddt, file_data

from test_base import SetVersionBaseTest

def has_dch_executable():
    """the devscripts package is needed to be able to use 'dch'"""
    with open(os.devnull, "wb") as devnull:
        try:
            subprocess.check_call("dch --version",
                                  stdout=devnull, stderr=devnull, shell=True)
        except subprocess.CalledProcessError:
            return False
        else:
            return True

@ddt
@unittest.skipUnless(has_dch_executable(), "'dch' executable not available")
class SetVersionDebianChangelog(SetVersionBaseTest):
    """Test set_version service for debian/changelog files"""

def _write_debian_changelog(self, filename, version):
        # debian changelogs can't be created with empty versions
        if not version.strip():
            version = "0~0"
        subprocess.check_call("dch --create --empty -v "
                              "%s --package foobar -c %s" %
                              (version, filename), shell=True)
        return os.path.join(self._tmpdir, filename)

@file_data("data_test_from_commandline.json")
    def test_from_commandline(self, data):
        old_version, new_version = data
        changelog_path = self._write_debian_changelog(
            "debian.changelog", old_version)
        self._run_set_version(params=['--version', new_version])
        self._check_file_assert_contains(changelog_path, new_version)
        self._check_file_assert_not_contains(changelog_path, old_version)

@file_data("data_test_from_tarball_with_single_file.json")
    def test_from_tarball_with_single_file(self, data):
        tarball_name, tarball_dirs, old_version, expected_version = data
        changelog_path = self._write_debian_changelog(
            "debian.changelog", old_version)
        self._write_tarfile(tarball_name, tarball_dirs, [])
        self._run_set_version()
        self._check_file_assert_contains(changelog_path, expected_version)
        if old_version.strip():
            self._check_file_assert_not_contains(changelog_path, old_version)

@file_data("data_test_from_tarball_with_basename_with_multiple_files.json")
    def test_from_tarball_with_basename_with_multiple_files(self, data):
        tarball_name, tarball_dirs, expected_version, dchlog_files = data
        dchlog_path = []
        old_version = "9.9.9-1foobar3"
        for s in filter(lambda x: x.endswith("debian.changelog"),
                        dchlog_files):
            dchlog_path.append(
                self._write_debian_changelog(s, old_version))
        self._write_tarfile(tarball_name, tarball_dirs, [])
        self._run_set_version(["--basename", "testprog"])
        for s in dchlog_path:
            self._check_file_assert_contains(s, expected_version)
            self._check_file_assert_not_contains(s, old_version)

@file_data("data_test_from_tarball_with_basename.json")
    def test_from_tarball_with_basename(self, data):
        tarball_name, tarball_dirs, expected_version = data
        old_version = "9.9.9-0+git3~10"
        dchlog_path = self._write_debian_changelog("debian.changelog",
                                                   old_version)
        self._write_tarfile(tarball_name, tarball_dirs, [])
        self._run_set_version(["--basename", "testprog"])
        self._check_file_assert_contains(dchlog_path, expected_version)
        self._check_file_assert_not_contains(dchlog_path, old_version)
0707010C78E2B5000081A4000000020000000200000001595A67C400000613000000FE0000002100000000000000000000004300000000obs-service-set_version-0.5.6/tests/test_package_type_detection.py# Copyright (C) 2015 SUSE Linux GmbH
#
# 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, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,USA.

import imp

from ddt import data, ddt, unpack

from test_base import SetVersionBaseTest

# NOTE(toabctl): Hack to import non-module file for testing
sv = imp.load_source("set_version", "set_version")

@ddt
class PackageTypeDetector(SetVersionBaseTest):
    @data(
        ("test.tar", [], ["test.egg-info/PKG-INFO"], "python"),
        ("test.tar", [], ["test-1.2.3a1/test.egg-info/PKG-INFO"], "python"),
        ("test.tar", [], ["PKG-INFO"], None),
        ("test.tar", [], ["foo.py"], None)
    )
    @unpack
    def test_detection(self, tar_name, tar_dirs, tar_files, expected_result):
        self._write_tarfile(tar_name, tar_dirs, tar_files)
        files = sv._get_local_files()
        pack_type = sv.PackageTypeDetector._get_package_type(files)
        self.assertEqual(expected_result, pack_type)
0707010C78E2B6000081A4000000020000000200000001595A67C40000076E000000FE0000002100000000000000000000003500000000obs-service-set_version-0.5.6/tests/test_pkgbuild.py# Copyright (C) 2015 SUSE Linux GmbH
#
# 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, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,USA.

import os

from ddt import ddt, file_data

from test_base import SetVersionBaseTest

@ddt
class SetVersionPKGBUILD(SetVersionBaseTest):
    """Test set_version service for PKGBUILD files"""

def _write_pkgbuild_file(self, pkgbuild_name, tags, custom=[]):
        """write a given filename with the given tags and custom
        strings"""
        pkgbuild_path = os.path.join(self._tmpdir, pkgbuild_name)
        with open(pkgbuild_path, "a") as f:
            for c in custom:
                f.write("%s\n" % c)
            for key, val in tags.items():
                f.write("%s=%s\n" % (key, val))
            f.write("\n")
        return pkgbuild_path

@file_data("data_test_from_commandline.json")
    def test_from_commandline(self, data):
        old_version, new_version = data
        pkgbuild_path = self._write_pkgbuild_file(
            "PKGBUILD", {"pkgver": old_version})
        self._run_set_version(params=['--version', new_version])
        expected_str = "pkgver=%s" % (new_version)
        self._check_file_assert_contains(pkgbuild_path, expected_str)
        self._check_file_assert_not_contains(pkgbuild_path, old_version)
0707010C78E2B7000081A4000000020000000200000001595A67C400002780000000FE0000002100000000000000000000003B00000000obs-service-set_version-0.5.6/tests/test_python_pip2rpm.py# Copyright (C) 2015 SUSE Linux GmbH
#
# 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, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,USA.

import imp
import os
import subprocess
import unittest

from ddt import data, ddt, unpack

from packaging.version import parse

from test_base import SetVersionBaseTest

# NOTE(toabctl): Hack to import non-module file for testing
sv = imp.load_source("set_version", "set_version")

def _has_zypper():
    with open(os.devnull, 'w') as dn:
        ret = subprocess.call("which zypper",
                              stdout=dn, stderr=subprocess.STDOUT,
                              shell=True)
        if int(ret) == 0:
            return True
        return False

def _has_dpkg():
    with open(os.devnull, 'w') as dn:
        ret = subprocess.call("which dpkg",
                              stdout=dn, stderr=subprocess.STDOUT,
                              shell=True)
        if int(ret) == 0:
            return True
        return False

HAS_ZYPPER = _has_zypper()
HAS_DPKG = _has_dpkg()

class VersionCompareBase(object):
    def __init__(self, version):
        self.version_str = version

def __repr__(self):
        return self.version_str

class ZypperVersionCompare(VersionCompareBase):
    """ class to compare version strings with zypper"""
    def __cmp__(self, other):
        # zypper's return val is negative if v1 is older than v2.
        # See 'man zypper'
        ret = subprocess.check_output("zypper --terse versioncmp %s %s" % (
            self.version_str, other.version_str), shell=True)
        return int(ret)

class DpkgVersionCompare(VersionCompareBase):
    def __do_compare(self, other, op):
        cmd = 'dpkg --compare-versions "%s" "%s" "%s"' % (
            self.version_str, op, other.version_str)
        ret = subprocess.call(cmd, shell=True)
        if int(ret) == 0:
            return True
        return False

def __lt__(self, other):
        return self.__do_compare(other, 'lt')

def __le__(self, other):
        return self.__do_compare(other, 'le')

def __eq__(self, other):
        return self.__do_compare(other, 'eq')

def __gt__(self, other):
        return self.__do_compare(other, 'gt')

def __ge__(self, other):
        return self.__do_compare(other, 'ge')

@ddt
class VersionConverterTest(SetVersionBaseTest):
    @data(
        ('1', '1'),
        ('1.0', '1.0'),
        ('1.0.1', '1.0.1'),
        ('5.0.0.0a1.dev13', '5.0.0.0~a1~dev13'),
        ('2015.2.b123', '2015.2~b123'),
        ('1.2-dev2', '1.2~a0~dev2'),
        ('1.0.post1', '1.0.post1'),
        ('1.0rc1', '1.0~rc1'),
        ('1.0b1', '1.0~b1')
    )
    @unpack
    def test_python_version_pip2rpm(self, pip_ver, expected_ver):
        """ See https://www.python.org/dev/peps/pep-0440/\
        #examples-of-compliant-version-schemes """
        rpm_ver = sv._version_python_pip2rpm(pip_ver)
        self.assertEqual(rpm_ver, expected_ver)

@ddt
@unittest.skipIf(HAS_ZYPPER is False and HAS_DPKG is False,
                 "zypper and dpkg are both unavailable")
class VersionCompareTests(SetVersionBaseTest):
    def _do_version_compare(self, v1, op, v2):
        """ make sure that a version compare with pip and
        zypper leads to the same result"""
        # parse pip versions
        v1_pip = parse(v1)
        v2_pip = parse(v2)
        # generate rpm version strings
        v1_rpm = sv._version_python_pip2rpm(v1)
        v2_rpm = sv._version_python_pip2rpm(v2)
        checked_package_managers = [('pip', v1_pip, v2_pip)]
        # generate Zypper objects to be able to compare the strings
        if HAS_ZYPPER:
            v1_zypp = ZypperVersionCompare(v1_rpm)
            v2_zypp = ZypperVersionCompare(v2_rpm)
            checked_package_managers.append(('zypper', v1_zypp, v2_zypp))
        # generate dpkg objects to be able to compare the strings
        if HAS_DPKG:
            v1_dpkg = DpkgVersionCompare(v1_rpm)
            v2_dpkg = DpkgVersionCompare(v2_rpm)
            checked_package_managers.append(('dpkg', v1_dpkg, v2_dpkg))
        # compare version strings for pip, zypper and dpkg
        for type_, vv1, vv2 in checked_package_managers:
            if op == '==':
                self.assertEqual(vv1, vv2,
                                 "%s: %s == %s" % (type_, vv1, vv2))
            elif op == '>':
                self.assertGreater(vv1, vv2,
                                   "%s: %s > %s" % (type_, vv1, vv2))
            elif op == '>=':
                self.assertGreaterEqual(vv1, vv2,
                                        "%s: %s >= %s" % (type_, vv1, vv2))
            elif op == '<':
                self.assertLess(vv1, vv2,
                                "%s: %s < %s" % (type_, vv1, vv2))
            elif op == '<=':
                self.assertLessEqual(vv1, vv2,
                                     "%s: %s <= %s" % (type_, vv1, vv2))
            else:
                raise Exception("Unknown operator '%s'" % op)

@data(
        # pre release spelling
        # https://www.python.org/dev/peps/pep-0440/#pre-release-spelling
        (
            [
                '1.1a', '1.1-a', '1.1.a', '1.1_a',
                '1.1A', '1.1-A', '1.1.A', '1.1_A',
                '1.1a0', '1.1-a0', '1.1.a0', '1.1_a0',
                '1.1A0', '1.1-A0', '1.1.A0', '1.1_A0',
                '1.1alpha', '1.1-alpha', '1.1.alpha', '1.1_alpha',
                '1.1ALPHA', '1.1-ALPHA', '1.1.ALPHA', '1.1_ALPHA',
                '1.1alpha0', '1.1-alpha0', '1.1.alpha0', '1.1_alpha0',
                '1.1ALPHA0', '1.1-ALPHA0', '1.1.ALPHA0', '1.1_ALPHA0'],
            '==',
            '1.1a0'
        ),
        (
            [
                '1.1b', '1.1-b', '1.1.b', '1.1_b',
                '1.1B', '1.1-B', '1.1.B', '1.1_B',
                '1.1b0', '1.1-b0', '1.1.b0', '1.1_b0',
                '1.1B0', '1.1-B0', '1.1.B0', '1.1_B0',
                '1.1beta', '1.1-beta', '1.1.beta', '1.1_beta',
                '1.1BETA', '1.1-BETA', '1.1.BETA', '1.1_BETA',
                '1.1beta0', '1.1-beta0', '1.1.beta0', '1.1_beta0',
                '1.1BETA0', '1.1-BETA0', '1.1.BETA0', '1.1_BETA0'],
            '==',
            '1.1b0'
        ),
        (
            [
                '1.1c', '1.1-c', '1.1.c', '1.1_c',
                '1.1C', '1.1-C', '1.1.C', '1.1_C',
                '1.1c0', '1.1-c0', '1.1.c0', '1.1_c0',
                '1.1C0', '1.1-C0', '1.1.C0', '1.1_C0',
                '1.1rc', '1.1-rc', '1.1.rc', '1.1_rc',
                '1.1RC', '1.1-RC', '1.1.RC', '1.1_RC',
                '1.1rc0', '1.1-rc0', '1.1.rc0', '1.1_rc0',
                '1.1RC0', '1.1-RC0', '1.1.RC0', '1.1_RC0',
                '1.1pre', '1.1-pre', '1.1.pre', '1.1_pre',
                '1.1PRE', '1.1-PRE', '1.1.PRE', '1.1_PRE',
                '1.1pre0', '1.1-pre0', '1.1.pre0', '1.1_pre0',
                '1.1PRE0', '1.1-PRE0', '1.1.PRE0', '1.1_PRE0',
                '1.1preview', '1.1-preview', '1.1.preview', '1.1_preview',
                '1.1PREVIEW', '1.1-PREVIEW', '1.1.PREVIEW', '1.1_PREVIEW',
                '1.1preview0', '1.1-preview0', '1.1.preview0', '1.1_preview0',
                '1.1PREVIEW0', '1.1-PREVIEW0', '1.1.PREVIEW0', '1.1_PREVIEW0',
            ],
            '==',
            '1.1rc0'
        ),
    )
    @unpack
    def test_version_normalization(self, v1_list, op, v2):
        """ test packaging's version normalization. There are crazy thinks
        like foo-1.0rc0.post1.dev5 possible"""
        # do the tests with and without 'post' releases
        # FIXME(toabctl): See https://github.com/pypa/packaging/issues/35
        # for post releases, also check 'r', 'R', 'ref' and 'REF'
        for p in ['',
                  'post', '-post', '.post', '_post',
                  'post0', '-post0', '.post0', '_post0']:
            # do the tests with and without 'dev' releases
            for d in ['',
                      'dev', '-dev', '.dev', '_dev',
                      'dev0', '-dev0', '.dev0', '_dev0']:
                for vv1 in v1_list:
                    self._do_version_compare("%s%s%s" % (vv1, p, d),
                                             op,
                                             "%s%s%s" % (v2, p, d))

@data(
        (
            [
                '1.1.post10+localver.1',
                '1.1.post10',
                '1.1.post10.dev10+local1',
                '1.1.post10.dev10',
                '1.1+local1',
                '1.1',
                '1.1rc10.post10+local1',
                '1.1rc10.post10',
                '1.1rc10.post10.dev10+local1',
                '1.1rc10.post10.dev10',
                '1.1rc9+local1',
                '1.1rc9',
                '1.1b10.post10+local1',
                '1.1b10.post10',
                '1.1b10.post10.dev10+local1',
                '1.1b10.post10.dev10',
                '1.1b10+local1',
                '1.1b10',
                '1.1a10.post10+local1',
                '1.1a10.post10',
                '1.1a10.post10.dev10+local1',
                '1.1a10.post10.dev10',
                '1.1a10+local1',
                '1.1a10',
                '1.1.dev10+local1',
                '1.1.dev10',
            ],
            '>'
        )
    )
    @unpack
    def test_version_ordering(self, version_chain, op):
        """ version order should be same between pip and zypper"""
        for i, _ in enumerate(version_chain[:-1]):
            self._do_version_compare(version_chain[i], op, version_chain[i+1])
0707010C78E2B8000081A4000000020000000200000001595A67C400002997000000FE0000002100000000000000000000003400000000obs-service-set_version-0.5.6/tests/test_rpmspec.py# Copyright (C) 2015 SUSE Linux GmbH
#
# 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, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,USA.

import os
import imp
from ddt import data, ddt, file_data, unpack

from test_base import SetVersionBaseTest

sv = imp.load_source("set_version", "set_version")

@ddt
class SetVersionSpecfile(SetVersionBaseTest):
    """Test set_version service for .spec files"""

def _write_obsinfo(self, filename, version):
        # debian changelogs can't be created with empty versions
        if not version.strip():
            version = "0~0"
        obsinfo_file = open(filename, "w")
        obsinfo_file.write("name: my_base_name\n")
        obsinfo_file.write("version: %s\n" % version)
        obsinfo_file.write("mtime: 1463080107\n")
        obsinfo_file.write("commit: "
                           "01fcec0959b42a163a7b0a943933488a217f2c9a\n")
        obsinfo_file.close()
        return os.path.join(self._tmpdir, filename)

def _write_specfile(self, spec_name, spec_tags, custom=[]):
        """write a given filename with the given rpm tags and custom
        strings (i.e. '%define foo bar')"""
        spec_path = os.path.join(self._tmpdir, spec_name)
        with open(spec_path, "a") as f:
            for c in custom:
                f.write("%s\n" % c)
            for key, val in spec_tags.items():
                f.write("%s: %s\n" % (key, val))
            f.write("\n")
        return spec_path

def test_version_from_obsinfo(self):
        obsinfo = self._write_obsinfo("test.obsinfo", "0.0.1")
        files = [obsinfo]
        ver = sv.VersionDetector._get_version_via_obsinfo(files, '')
        self.assertEqual(ver, "0.0.1")

@file_data("data_test_from_commandline.json")
    def test_from_commandline(self, data):
        old_version, new_version = data
        spec_path = self._write_specfile("test.spec", {"Version": old_version})
        self._run_set_version(params=['--version', new_version])
        self._check_file_assert_contains(spec_path, new_version)

@file_data("data_test_from_commandline_with_single_file.json")
    def test_from_commandline_with_single_file(self, data):
        spec_tags, new_version, spec_file, other_spec_files = data
        """only a single .spec file should contain the given version"""
        spec_path = self._write_specfile(spec_file, spec_tags)
        # other spec file which shouldn't be updated
        other_spec_path = []
        for s in other_spec_files:
            other_spec_path.append(self._write_specfile(s, spec_tags))
        self._run_set_version(params=["--version", new_version,
                                      "--file", spec_file])
        # our given spec should have the version
        self._check_file_assert_contains(spec_path, new_version)
        # all others shouldn't
        for s in other_spec_path:
            self._check_file_assert_not_contains(s, new_version)

@file_data("data_test_from_commandline_with_multiple_files.json")
    def test_from_commandline_with_multiple_files(self, data):
        """all .spec files should contain the given version"""
        spec_tags, new_version, spec_files = data
        spec_path = []
        for s in spec_files:
            spec_path.append(self._write_specfile(s, spec_tags))
        self._run_set_version(params=["--version", new_version])
        for s in spec_path:
            self._check_file_assert_contains(s, new_version)

@file_data("data_test_from_tarball_with_single_file.json")
    def test_from_tarball_with_single_file(self, data):
        tarball_name, tarball_dirs, old_version, expected_version = data
        spec_path = self._write_specfile("test.spec",
                                         {"Name": "foo",
                                          "Version": old_version,
                                          "Group": "AnyGroup"})
        self._write_tarfile(tarball_name, tarball_dirs, [])
        self._run_set_version()
        self._check_file_assert_contains(spec_path, expected_version)
        self._check_file_assert_contains(spec_path, "Name: foo")
        self._check_file_assert_contains(spec_path, "Group: AnyGroup")

@file_data("data_test_from_tarball_with_single_file.json")
    def test_from_obsinfo(self, data):
        tarball_name, tarball_dirs, old_version, expected_version = data
        self._write_obsinfo("test.obsinfo", expected_version)
        spec_path = self._write_specfile("test.spec",
                                         {"Name": "foo",
                                          "Version": old_version,
                                          "Group": "AnyGroup"})
        self._run_set_version()
        self._check_file_assert_contains(spec_path, expected_version)
        self._check_file_assert_contains(spec_path, "Name: foo")
        self._check_file_assert_contains(spec_path, "Group: AnyGroup")

@file_data("data_test_from_tarball_with_basename_with_multiple_files.json")
    def test_from_tarball_with_basename_with_multiple_files(self, data):
        tarball_name, tarball_dirs, expected_version, spec_files = data
        spec_path = []
        for s in filter(lambda x: x.endswith(".spec"), spec_files):
            spec_path.append(self._write_specfile(s, {"Version": "UNKNOWN"}))
        self._write_tarfile(tarball_name, tarball_dirs, [])
        self._run_set_version(["--basename", "testprog"])
        for s in spec_path:
            self._check_file_assert_contains(s, expected_version)

@file_data("data_test_from_tarball_with_basename.json")
    def test_from_tarball_with_basename(self, data):
        tarball_name, tarball_dirs, expected_version = data
        spec_path = self._write_specfile("test.spec", {"Version": "UNKNOWN"})
        self._write_tarfile(tarball_name, tarball_dirs, [])
        self._run_set_version(["--basename", "testprog"])
        self._check_file_assert_contains(spec_path, expected_version)

@data(
        (
            "test.spec",
            "test-master.tar", [],
            ["test-5.0.0.0b2dev188/test.egg-info/PKG-INFO"],
            "5.0.0.0b2dev188",
            "5.0.0.0~b2~dev188"
        )
    )
    @unpack
    def test_python_package_from_tarball_with_single_file(
            self, spec_file, tar_name, tar_dirs, tar_files,
            org_version, conv_version):
        spec_path = self._write_specfile(
            spec_file, {"Name": "test",
                        "Version": "UNKNOWN",
                        "Group": "AnyGroup"},
            ["%define foo bar"])
        self._write_tarfile(tar_name, tar_dirs, tar_files)
        self._run_set_version()
        self._check_file_assert_contains(
            spec_path, "Version: %s" % conv_version)
        self._check_file_assert_contains(
            spec_path, "define version_unconverted %s" % org_version)
        self._check_file_assert_contains(
            spec_path, "Name: test")
        self._check_file_assert_contains(
            spec_path, "Group: AnyGroup")
        self._check_file_assert_contains(
            spec_path, "%define foo bar")
        self._check_file_assert_not_contains(spec_path, "UNKNOWN")

@data(
        (
            "test.spec",
            [
                "Version: 1.2.3",
                "Name: test",
                "%define component test",
                "%setup -p -n %{component}-%{version}"
            ],
            [
                "Version: 5.0.0.0~b2~dev188",
                "%define version_unconverted 5.0.0.0b2dev188",
                "",
                "Name: test",
                "%define component test",
                "%setup -p -n %{component}-%{version_unconverted}"
            ],
            "test-master.tar",
            [],
            ["test-5.0.0.0b2dev188/test.egg-info/PKG-INFO"]
        ),
        (
            "test.spec",
            [
                "Version: 1.2.3",
                "Name: test",
                "%define component version",
                "%setup -p -n %{component}-%{version}-foobar"
            ],
            [
                "Version: 5.0.0.0~b2~dev188",
                "%define version_unconverted 5.0.0.0b2dev188",
                "",
                "Name: test",
                "%define component version",
                "%setup -p -n %{component}-%{version_unconverted}-foobar"
            ],
            "test-master.tar",
            [],
            ["test-5.0.0.0b2dev188/test.egg-info/PKG-INFO"]
        ),
        (
            "test.spec",
            [
                "Version: 5.0.0.0~b2~dev188",
                "%define version_unconverted 5.0.0.0b2dev188",
            ],
            [
                "Version: 5.1.0",
                "%define version_unconverted 5.1.0",
            ],
            "test-master.tar",
            [],
            ["test-5.1.0/test.egg-info/PKG-INFO"]
        ),
        (
            "test.spec",
            [
                "Version: 1.2.3",
                "Name: test",
                "%define component test",
                "%setup -p -n %{component}-%{version}"
            ],
            [
                "Version: 5.0.0",
                "Name: test",
                "%define component test",
                "%setup -p -n %{component}-%{version}"
            ],
            "test-master.tar",
            [],
            ["test-5.0.0/test.egg-info/PKG-INFO"]
        ),
    )
    @unpack
    def test_python_package(
            self, spec_file, spec_lines, expected_spec_lines,
            tar_name, tar_dirs, tar_files):
        fn = os.path.join(self._tmpdir, spec_file)
        with open(fn, "w") as f:
            f.write("\n".join(spec_lines))
        self._write_tarfile(tar_name, tar_dirs, tar_files)
        self._run_set_version()
        # check
        with open(fn, "r") as f:
            current_lines = f.read().split("\n")
            self.assertEqual(len(current_lines), len(expected_spec_lines))
            for nbr, l in enumerate(current_lines):
                self.assertEqual(l, expected_spec_lines[nbr])
070701048D5720000041ED000000020000000200000003595A67C400000000000000FE0000002100000000000000000000002500000000obs-service-set_version-0.5.6/debian0707010C78E288000041ED000000020000000200000002595A67C400000000000000FE0000002100000000000000000000002400000000obs-service-set_version-0.5.6/tests0707011C1DB924000081A4000000020000000200000001595A67C4000001FD000000FE0000002100000000000000000000002A00000000obs-service-set_version-0.5.6/.travis.yml# Docker Infrastructure (see http://blog.travis-ci.com/2014-12-17-faster-builds-with-container-based-infrastructure/ )
sudo: false

language: python
python:
  - "2.7"
  - "3.3"
  - "3.4"

# see http://docs.travis-ci.com/user/apt/#Adding-APT-Packages for adding packages in a container build
addons:
    apt:
      packages:
        - devscripts
        - dpkg

install:
  - pip install flake8 ddt unittest2 packaging --use-mirrors
script:
  - flake8 set_version tests/
  - python -m unittest discover tests/

0707011C1F4F32000081A4000000020000000200000001595A67C4000000F1000000FE0000002100000000000000000000002700000000obs-service-set_version-0.5.6/Makefileprefix = /usr

servicedir = ${prefix}/lib/obs/service

all:

install:
	install -d $(DESTDIR)$(servicedir)
	install -m 0755 set_version $(DESTDIR)$(servicedir)
	install -m 0644 set_version.service $(DESTDIR)$(servicedir)

.PHONY: all install
0707011C1F4F33000081A4000000020000000200000001595A67C40000047E000000FE0000002100000000000000000000002800000000obs-service-set_version-0.5.6/README.md# set_version (OBS source service) [![Build Status](https://travis-ci.org/openSUSE/obs-service-set_version.svg?branch=master)](https://travis-ci.org/openSUSE/obs-service-set_version)

This service updates a RPM spec or Debian changelog according to the existing files.
The service can be used in combination with other services like [download_files](https://github.com/openSUSE/obs-service-download_files)
or [tar_scm](https://github.com/openSUSE/obs-service-tar_scm).
This is the git repository for [openSUSE:Tools/obs-service-set_version](https://build.opensuse.org/package/show/openSUSE:Tools/obs-service-set_version).
The authoritative source is https://github.com/openSUSE/obs-service-set_version

## Dependencies
Install the following deps:

zypper in python-packaging

## Test suite
To run the full testsuite, some dependencies are needed:

zypper in devscripts dpkg

If the dependencies are not installed, some tests are skipped. `zypper` itself
is also needed for the tests with python packages and PEP440 compatible versions.

To run the testsuite, execute:

python -m unittest discover tests/

The testrun may take some time.
0707011C1F4F34000081ED000000020000000200000001595A67C4000033DF000000FE0000002100000000000000000000002A00000000obs-service-set_version-0.5.6/set_version#!/usr/bin/python
# -*- coding: utf-8 -*-

# A simple script to update version number in spec, dsc or arch linux files
#
# (C) 2010 by Adrian Schröter <adrian@suse.de>
# (C) 2015 by Thomas Bechtold <tbechtold@suse.com>
#
# 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.
# See http://www.gnu.org/licenses/gpl-2.0.html for full license text.

from __future__ import print_function

import argparse
import glob
import os
import re
import shutil
import sys
import tarfile
import zipfile

try:
    from packaging.version import LegacyVersion, Version, parse
except:
    HAS_PACKAGING = False
    import warnings
    warnings.warn("install 'packaging' to improve python package versions",
                  RuntimeWarning)
else:
    HAS_PACKAGING = True

outdir = None
suffixes = ('obscpio', 'tar', 'tar.gz', 'tgz', 'tar.bz2', 'tbz2', 'tar.xz',
            'zip')
suffixes_re = "|".join(map(lambda x: re.escape(x), suffixes))

def _get_local_files():
    """ sorted local file list by modification time (newest first)"""
    files = glob.glob('*')
    files.sort(key=lambda x: os.stat(os.path.join(os.getcwd(), x)).st_mtime,
               reverse=True)
    return files

class VersionDetector(object):
    @staticmethod
    def _autodetect(files, basename):
        version = VersionDetector._get_version_via_obsinfo(
            files, basename)
        if not version:
            version = VersionDetector._get_version_via_archive_dirname(
                files, basename)
        if not version:
            version = VersionDetector._get_version_via_filename(
                files, basename)
        if not version:
            version = VersionDetector._get_version_via_debian_changelog(
                "debian.changelog")
        return version

@staticmethod
    def _get_version_via_filename(files, basename):
        """ detect version based on file names"""
        for f in files:
            regex = r"^%s.*[-_]([\d].*)\.(?:%s)$" % (re.escape(basename),
                                                     suffixes_re)
            m = re.match(regex, f)
            if m:
                return m.group(1)
        # Nothing found
        return None

@staticmethod
    def __get_version(str_list, basename):
        regex = "%s.*[-_]([\d][^\/]*).*" % basename
        for s in str_list:
            m = re.match(regex, s)
            if m:
                return m.group(1)
        # Nothing found
        return None

@staticmethod
    def _get_version_via_archive_dirname(files, basename):
        """ detect version based tar'd directory name"""
        for f in filter(lambda x: x.endswith(suffixes), files):
            # handle tarfiles
            if tarfile.is_tarfile(f):
                with tarfile.open(f) as tf:
                    v = VersionDetector.__get_version(tf.getnames(), basename)
                    if v:
                        return v
            # handle zipfiles
            if zipfile.is_zipfile(f):
                with zipfile.ZipFile(f, 'r') as zf:
                    v = VersionDetector.__get_version(zf.namelist(), basename)
                    if v:
                        return v
        # Nothing found
        return None

@staticmethod
    def _get_version_via_obsinfo(files, basename):
        join_suffix = basename + ".obsinfo"
        for filename in filter(lambda x: x.endswith(join_suffix), files):
            if os.path.exists(filename):
                with open(filename, "r") as fp:
                    for line in fp:
                        if line.startswith("version: "):
                            string = line[9:]
                            string = string.rstrip()
                            return string
        # Nothing found
        return None

@staticmethod
    def _get_version_via_debian_changelog(filename):
        # from http://anonscm.debian.org/cgit/pkg-python-debian/\
            # python-debian.git/tree/lib/debian/changelog.py
        topline = re.compile(r'^(\w%(name_chars)s*) $([^\($ \t]+)\)'
                             '((\s+%(name_chars)s+)+)\;'
                             % {'name_chars': '[-+0-9a-z.]'},
                             re.IGNORECASE)
        if os.path.exists(filename):
            with open(filename, "r") as f:
                firstline = f.readline()
                topmatch = topline.match(firstline)
                if topmatch:
                    return topmatch.group(2)
        # Nothing found
        return None

class PackageTypeDetector(object):
    @staticmethod
    def _get_package_type(files):
        pt_found = False
        for f in filter(lambda x: x.endswith(suffixes), files):
            pt_found = PackageTypeDetector._is_python(f)
            if pt_found:
                return "python"
        # no package type found
        return None

@staticmethod
    def _is_python(f):
        names = []
        if tarfile.is_tarfile(f):
            with tarfile.open(f) as tf:
                names = tf.getnames()
        if zipfile.is_zipfile(f):
            with zipfile.ZipFile(f, 'r') as zf:
                names = zf.namelist()
        for n in map(lambda x: os.path.normpath(x), names):
            if n.endswith("egg-info/PKG-INFO"):
                return True
        return False

def _replace_define(filename, def_name, def_value, add_if_missing=True):
    # first, modify a copy of filename and then move it
    with open(filename, 'r+') as f:
        contents = f.read()
        f.seek(0)
        contents_new, subs = re.subn(
            r'^%define {def_name}(\s*)[^%].*'.format(
                def_name=def_name),
            r'%define {def_name}\g<1>{def_value}'.format(
                def_name=def_name, def_value=def_value),
            contents, flags=re.MULTILINE)
        if subs == 0 and add_if_missing:
            # seems there was no define. add new one before 'Name:'
            contents_new, subs = re.subn(
                r'^(Name:.*)$',
                r'%define {def_name} {def_value}\n\n\g<1>'.format(
                    def_name=def_name, def_value=def_value),
                contents, flags=re.MULTILINE)

f.truncate()
        f.write(contents_new)

def _replace_spec_setup(filename, version_define):
    # first, modify a copy of filename and then move it
    with open(filename, 'r+') as f:
        contents = f.read()
        f.seek(0)
        # %setup without "-n" uses implicit "-n" as "%{name}-%{version}"
        contents_new, subs = re.subn(
            r'^%setup\s*((?:-q)?)?\s*$',
            r'%setup \1 -n %{{name}}-%{{{version_define}}}'.format(
                version_define=version_define),
            contents, flags=re.MULTILINE)
        if subs == 0:
            # keep inline macros for rpm
            contents_new, subs = re.subn(
                r'^%setup(.*)%{version}(.*)$',
                r'%setup\g<1>%{{{version_define}}}\g<2>'.format(
                    version_define=version_define),
                contents, flags=re.MULTILINE)
        if subs > 0:
            f.truncate()
            f.write(contents_new)

def _replace_tag(filename, tag, string):
    # first, modify a copy of filename and then move it
    with open(filename, 'r+') as f:
        contents = f.read()
        f.seek(0)
        if filename.endswith("PKGBUILD") or filename.endswith("build.collax"):
            contents_new, subs = re.subn(
                r"^{tag}=.*".format(tag=tag),
                r"{tag}={string}".format(tag=tag, string=string), contents,
                flags=re.MULTILINE)
        else:
            # keep inline macros for rpm
            contents_new, subs = re.subn(
                r'^{tag}:([ \t\f\v]*)[^%\n\r]*'.format(tag=tag),
                r'{tag}:\g<1>{string}'.format(
                    tag=tag, string=string),
                contents, flags=re.MULTILINE)
        if subs > 0:
            f.truncate()
            f.write(contents_new)

def _replace_debian_changelog_version(filename, version_new):
    # first, modify a copy of filename and then move it
    # get current version
    version_current = VersionDetector._get_version_via_debian_changelog(
        filename)
    with open(filename, 'r+') as f:
        content_lines = f.readlines()
        f.seek(0)
        content_lines[0] = content_lines[0].replace(
            version_current, version_new, 1)
        f.truncate()
        f.writelines(content_lines)

def _version_python_pip2rpm(version_pip):
    """generate a rpm compatible version from a python pip version"""
    version_rpm = version_pip
    if not HAS_PACKAGING:
        return version_rpm

v = parse(version_pip)
    if isinstance(v, Version):
        # this is a PEP440 conform version
        # TODO(toabctl): there's a epoch in PEP440. Howto handle these without
        # using rpm's epoch feature?
        parts = []
        # Release segment
        parts.append(".".join(str(x) for x in v._version.release))

# Pre-release
        if v._version.pre is not None:
            parts.append("~")
            parts.append("".join(str(x) for x in v._version.pre))

# Post-release
        if v._version.post is not None:
            parts.append(".post{0}".format(v._version.post[1]))

# Development release
        if v._version.dev is not None:
            if v._version.pre is None:
                parts.append("~a0")
            parts.append("~dev{0}".format(v._version.dev[1]))

# Local version segment
        if v._version.local is not None:
            parts.append(
                "+{0}".format(".".join(str(x) for x in v._version.local))
            )
        version_rpm = "".join(parts)
    elif isinstance(v, LegacyVersion):
        # TODO(toabctl): handle setuptools style legacy version
        pass

return version_rpm

if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        description='Open Build Service source service "set_version".'
        'Used to update build description files with a '
        'detected or given version number.')
    parser.add_argument('--outdir', required=True,
                        help='output directory for modified sources')
    parser.add_argument('--version',
                        help='use given version string, do not detect it '
                        'from source files')
    parser.add_argument('--basename', default="",
                        help='detect version based on the file name with '
                        'a given prefix')
    parser.add_argument('--file', action='append',
                        help='modify only this build description. '
                        'maybe used multiple times.')
    args = vars(parser.parse_args())

version = args['version']

files_local = _get_local_files()

outdir = args['outdir']

if not outdir:
        print("no outdir specified")
        sys.exit(-1)

if not version:
        version = VersionDetector._autodetect(files_local, args["basename"])

if not version:
        print("unable to detect the version")
        sys.exit(-1)

# if no files explicitly specified process whole directory
    files = args['file'] or files_local

# do version convertion if needed
    pack_type = PackageTypeDetector._get_package_type(files)
    version_converted = None
    if pack_type == "python":
        version_converted = _version_python_pip2rpm(version)

# handle rpm specs
    for f in filter(lambda x: x.endswith(".spec"), files):
        filename = outdir + "/" + f
        shutil.copyfile(f, filename)
        _replace_define(filename, "version_unconverted", version,
                        add_if_missing=False)
        if version_converted and version_converted != version:
            _replace_define(filename, "version_unconverted", version)
            _replace_tag(filename, 'Version', version_converted)
            _replace_spec_setup(filename, "version_unconverted")
        else:
            _replace_tag(filename, 'Version', version)
        _replace_tag(filename, 'Release', "0")

# handle debian packages
    for f in filter(lambda x: x.endswith(".dsc"), files):
        filename = outdir + "/" + f
        shutil.copyfile(f, filename)
        _replace_tag(filename, 'Version', version + "-0")

for f in filter(lambda x: x.endswith(("debian.changelog")), files):
        filename = outdir + "/" + f
        shutil.copyfile(f, filename)
        _replace_debian_changelog_version(filename, version + "-0")

# handle build.collax recipes
    for f in filter(lambda x: x.endswith(("build.collax")), files):
        filename = outdir + "/" + f
        shutil.copyfile(f, filename)
        _replace_tag(filename, "version", version)
        _replace_tag(filename, "build", "0")

# handle arch linux PKGBUILD files
    # TODO: Handle the md5sums generation!
    for f in filter(lambda x: x.endswith(("PKGBUILD")), files):
        filename = outdir + "/" + f
        shutil.copyfile(f, filename)
        _replace_tag(filename, "md5sums", "('SKIP')")
        _replace_tag(filename, "pkgver", version)
        _replace_tag(filename, "pkgrel", "0")
0707011C1F4F4A000081A4000000020000000200000001595A67C40000026F000000FE0000002100000000000000000000003200000000obs-service-set_version-0.5.6/set_version.service<service name="set_version">
  <summary>Updates version in spec and dsc files</summary>
  <description>This service updates a spec file according to the existing files.
Can be used after download_url or tar_scm service.
</description>
  <parameter name="version">
    <description>Set version to this value, otherwise autodetection is running.</description>
  </parameter>
  <parameter name="basename">
    <description>Limit version detection to files which start with given name.</description>
  </parameter>
  <parameter name="file">
    <description>Update only the given file.</description>
  </parameter>
</service>

07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!121 blocks

Places

File _service:obs_scm:obs-service-set_version-0.5.6.obscpio of Package obs-service-set_version (Revision ffd782ba6f886d750b308f565e73ce36)

Places