1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

# vim: set fileencoding=utf-8 : 

# 

# (C) 2011 Guido Günther <agx@sigxcpu.org> 

#    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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 

"""A Git Repository that keeps a Debian Package""" 

 

import re 

from gbp.git import GitRepository, GitRepositoryError 

from gbp.deb.pristinetar import DebianPristineTar 

 

class DebianGitRepository(GitRepository): 

    """A git repository that holds the source of a Debian package""" 

 

    def __init__(self, path): 

        super(DebianGitRepository, self).__init__(path) 

        self.pristine_tar = DebianPristineTar(self) 

 

    def find_version(self, format, version): 

        """ 

        Check if a certain version is stored in this repo and return the SHA1 

        of the related commit. That is, an annotated tag is dereferenced to the 

        commit object it points to. 

 

        For legacy tags don't only check the tag itself but also the commit 

        message, since the former wasn't injective until release 0.5.5. You 

        only need to use this function if you also need to check for legacy 

        tags. 

 

        @param format: tag pattern 

        @type format: C{str} 

        @param version: debian version number 

        @type version: C{str} 

        @return: sha1 of the commit the tag references to 

        @rtype: C{str} 

        """ 

        tag = self.version_to_tag(format, version) 

        legacy_tag = self._build_legacy_tag(format, version) 

        if self.has_tag(tag): # new tags are injective 

            # dereference to a commit object 

            return self.rev_parse("%s^0" % tag) 

        elif self.has_tag(legacy_tag): 

            out, ret = self._git_getoutput('cat-file', args=['-p', legacy_tag]) 

            if ret: 

                return None 

            for line in out: 

                if line.endswith(" %s\n" % version): 

                    # dereference to a commit object 

                    return self.rev_parse("%s^0" % legacy_tag) 

                elif line.startswith('---'): # GPG signature start 

                    return None 

        return None 

 

    @staticmethod 

    def _build_legacy_tag(format, version): 

        """ 

        Legacy tags (prior to 0.5.5) dropped epochs and didn't honor the '~' 

 

        >>> DebianGitRepository._build_legacy_tag('upstream/%(version)s', '1:2.0~3') 

        'upstream/2.0.3' 

        """ 

        if ':' in version: # strip of any epochs 

            version = version.split(':', 1)[1] 

        version = version.replace('~', '.') 

        return format % dict(version=version) 

 

    @staticmethod 

    def version_to_tag(format, version): 

        """Generate a tag from a given format and a version 

 

        >>> DebianGitRepository.version_to_tag("debian/%(version)s", "0:0~0") 

        'debian/0%0_0' 

        """ 

        return format % dict(version=DebianGitRepository._sanitize_version(version)) 

 

    @staticmethod 

    def _sanitize_version(version): 

        """sanitize a version so git accepts it as a tag 

 

        >>> DebianGitRepository._sanitize_version("0.0.0") 

        '0.0.0' 

        >>> DebianGitRepository._sanitize_version("0.0~0") 

        '0.0_0' 

        >>> DebianGitRepository._sanitize_version("0:0.0") 

        '0%0.0' 

        >>> DebianGitRepository._sanitize_version("0%0~0") 

        '0%0_0' 

        """ 

        return version.replace('~', '_').replace(':', '%') 

 

    @staticmethod 

    def tag_to_version(tag, format): 

        """Extract the version from a tag 

 

        >>> DebianGitRepository.tag_to_version("upstream/1%2_3-4", "upstream/%(version)s") 

        '1:2~3-4' 

        >>> DebianGitRepository.tag_to_version("foo/2.3.4", "foo/%(version)s") 

        '2.3.4' 

        >>> DebianGitRepository.tag_to_version("foo/2.3.4", "upstream/%(version)s") 

        """ 

        version_re = format.replace('%(version)s', 

                                    '(?P<version>[\w_%+-.]+)') 

        r = re.match(version_re, tag) 

        if r: 

            version = r.group('version').replace('_', '~').replace('%', ':') 

            return version 

        return None 

 

    @property 

    def pristine_tar_branch(self): 

        """ 

        The name of the pristine-tar branch, whether it already exists or 

        not. 

        """ 

        return DebianPristineTar.branch 

 

    def has_pristine_tar_branch(self): 

        """ 

        Wheter the repo has a I{pristine-tar} branch. 

 

        @return: C{True} if the repo has pristine-tar commits already, C{False} 

            otherwise 

        @rtype: C{Bool} 

        """ 

        return True if self.has_branch(self.pristine_tar_branch) else False 

 

# vim:et:ts=4:sw=4:et:sts=4:ai:set list listchars=tab\:»·,trail\:·: