/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/shelf.py

Merge with serialize-transform

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/shelf.py
 
1
# Copyright (C) 2008 Aaron Bentley <aaron@aaronbentley.com>
 
2
#
 
3
#    This program is free software; you can redistribute it and/or modify
 
4
#    it under the terms of the GNU General Public License as published by
 
5
#    the Free Software Foundation; either version 2 of the License, or
 
6
#    (at your option) any later version.
 
7
#
 
8
#    This program is distributed in the hope that it will be useful,
 
9
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
#    GNU General Public License for more details.
 
12
#
 
13
#    You should have received a copy of the GNU General Public License
 
14
#    along with this program; if not, write to the Free Software
 
15
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
from bzrlib import (
 
19
    merge3,
 
20
    osutils,
 
21
    pack,
 
22
    transform,
 
23
)
 
24
 
 
25
 
 
26
class ShelfCreator(object):
 
27
 
 
28
    def __init__(self, work_tree, target_tree, file_list=None):
 
29
        self.work_tree = work_tree
 
30
        self.work_transform = transform.TreeTransform(work_tree)
 
31
        self.target_tree = target_tree
 
32
        self.shelf_transform = transform.TransformPreview(self.target_tree)
 
33
        self.renames = {}
 
34
        self.creation = {}
 
35
        self.deletion = {}
 
36
        self.iter_changes = work_tree.iter_changes(self.target_tree,
 
37
                                                   specific_files=file_list)
 
38
 
 
39
    def __iter__(self):
 
40
        for (file_id, paths, changed, versioned, parents, names, kind,
 
41
             executable) in self.iter_changes:
 
42
            if kind[0] is None or versioned[0] == False:
 
43
                self.creation[file_id] = (kind[1], names[1], parents[1],
 
44
                                          versioned)
 
45
                yield ('add file', file_id, kind[1], paths[1])
 
46
            elif kind[1] is None or versioned[0] == False:
 
47
                self.deletion[file_id] = (kind[0], names[0], parents[0],
 
48
                                          versioned)
 
49
                yield ('delete file', file_id, kind[0], paths[0])
 
50
            else:
 
51
                if names[0] != names[1] or parents[0] != parents[1]:
 
52
                    self.renames[file_id] = (names, parents)
 
53
                    yield ('rename', file_id) + paths
 
54
 
 
55
                if kind[0] != kind [1]:
 
56
                    yield ('change kind', file_id, kind[0], kind[1], paths[0])
 
57
                elif changed:
 
58
                    yield ('modify text', file_id)
 
59
 
 
60
    def shelve_rename(self, file_id):
 
61
        names, parents = self.renames[file_id]
 
62
        w_trans_id = self.work_transform.trans_id_file_id(file_id)
 
63
        work_parent = self.work_transform.trans_id_file_id(parents[0])
 
64
        self.work_transform.adjust_path(names[0], work_parent, w_trans_id)
 
65
 
 
66
        s_trans_id = self.shelf_transform.trans_id_file_id(file_id)
 
67
        shelf_parent = self.shelf_transform.trans_id_file_id(parents[1])
 
68
        self.shelf_transform.adjust_path(names[1], shelf_parent, s_trans_id)
 
69
 
 
70
    def shelve_lines(self, file_id, new_lines):
 
71
        w_trans_id = self.work_transform.trans_id_file_id(file_id)
 
72
        self.work_transform.delete_contents(w_trans_id)
 
73
        self.work_transform.create_file(new_lines, w_trans_id)
 
74
 
 
75
        s_trans_id = self.shelf_transform.trans_id_file_id(file_id)
 
76
        self.shelf_transform.delete_contents(s_trans_id)
 
77
        inverse_lines = self._inverse_lines(new_lines, file_id)
 
78
        self.shelf_transform.create_file(inverse_lines, s_trans_id)
 
79
 
 
80
    @staticmethod
 
81
    def _content_from_tree(tt, tree, file_id):
 
82
        trans_id = tt.trans_id_file_id(file_id)
 
83
        tt.delete_contents(trans_id)
 
84
        transform.create_from_tree(tt, trans_id, tree, file_id)
 
85
 
 
86
    def shelve_content_change(self, file_id):
 
87
        self._content_from_tree(self.work_transform, self.target_tree, file_id)
 
88
        self._content_from_tree(self.shelf_transform, self.work_tree, file_id)
 
89
 
 
90
    def shelve_creation(self, file_id):
 
91
        kind, name, parent, versioned = self.creation[file_id]
 
92
        version = not versioned[0]
 
93
        self._shelve_creation(self.work_tree, file_id, self.work_transform,
 
94
                              self.shelf_transform, kind, name, parent,
 
95
                              version)
 
96
 
 
97
    def shelve_deletion(self, file_id):
 
98
        kind, name, parent, versioned = self.deletion[file_id]
 
99
        existing_path = self.target_tree.id2path(file_id)
 
100
        if not self.work_tree.has_filename(existing_path):
 
101
            existing_path = None
 
102
        version = not versioned[1]
 
103
        self._shelve_creation(self.target_tree, file_id, self.shelf_transform,
 
104
                              self.work_transform, kind, name, parent,
 
105
                              version, existing_path=existing_path)
 
106
 
 
107
    def _shelve_creation(self, tree, file_id, from_transform, to_transform,
 
108
                         kind, name, parent, version, existing_path=None):
 
109
        w_trans_id = from_transform.trans_id_file_id(file_id)
 
110
        if parent is not None and kind is not None:
 
111
            from_transform.delete_contents(w_trans_id)
 
112
        from_transform.unversion_file(w_trans_id)
 
113
 
 
114
        if existing_path is not None:
 
115
            s_trans_id = to_transform.trans_id_tree_path(existing_path)
 
116
        else:
 
117
            s_trans_id = to_transform.trans_id_file_id(file_id)
 
118
        if parent is not None:
 
119
            s_parent_id = to_transform.trans_id_file_id(parent)
 
120
            to_transform.adjust_path(name, s_parent_id, s_trans_id)
 
121
            if existing_path is None:
 
122
                if kind is None:
 
123
                    to_transform.create_file('', s_trans_id)
 
124
                else:
 
125
                    transform.create_from_tree(to_transform, s_trans_id,
 
126
                                               tree, file_id)
 
127
        if version:
 
128
            to_transform.version_file(file_id, s_trans_id)
 
129
 
 
130
    def read_tree_lines(self, tree, file_id):
 
131
        return osutils.split_lines(tree.get_file_text(file_id))
 
132
 
 
133
    def _inverse_lines(self, new_lines, file_id):
 
134
        """Produce a version with only those changes removed from new_lines."""
 
135
        target_lines = self.target_tree.get_file_lines(file_id)
 
136
        work_lines = self.read_tree_lines(self.work_tree, file_id)
 
137
        return merge3.Merge3(new_lines, target_lines, work_lines).merge_lines()
 
138
 
 
139
    def finalize(self):
 
140
        self.work_transform.finalize()
 
141
        self.shelf_transform.finalize()
 
142
 
 
143
    def transform(self):
 
144
        self.work_transform.apply()
 
145
 
 
146
    def make_shelf_filename(self):
 
147
        transport = self.work_tree.bzrdir.root_transport.clone('.shelf2')
 
148
        transport.ensure_base()
 
149
        return transport.local_abspath('01')
 
150
 
 
151
    def write_shelf(self):
 
152
        filename = self.make_shelf_filename()
 
153
        shelf_file = open(filename, 'wb')
 
154
        try:
 
155
            serializer = pack.ContainerSerialiser()
 
156
            shelf_file.write(serializer.begin())
 
157
            for bytes in self.shelf_transform.serialize(serializer):
 
158
                shelf_file.write(bytes)
 
159
            shelf_file.write(serializer.end())
 
160
        finally:
 
161
            shelf_file.close()
 
162
        return filename