/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/transform.py

merge trailing whitespace removal

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transform.py
233
233
 
234
234
    def adjust_root_path(self, name, parent):
235
235
        """Emulate moving the root by moving all children, instead.
236
 
        
 
236
 
237
237
        We do this by undoing the association of root's transaction id with the
238
238
        current tree.  This allows us to create a new directory with that
239
 
        transaction id.  We unversion the root directory and version the 
 
239
        transaction id.  We unversion the root directory and version the
240
240
        physically new directory, and hope someone versions the tree root
241
241
        later.
242
242
        """
245
245
        # force moving all children of root
246
246
        for child_id in self.iter_tree_children(old_root):
247
247
            if child_id != parent:
248
 
                self.adjust_path(self.final_name(child_id), 
 
248
                self.adjust_path(self.final_name(child_id),
249
249
                                 self.final_parent(child_id), child_id)
250
250
            file_id = self.final_file_id(child_id)
251
251
            if file_id is not None:
252
252
                self.unversion_file(child_id)
253
253
            self.version_file(file_id, child_id)
254
 
        
 
254
 
255
255
        # the physical root needs a new transaction id
256
256
        self._tree_path_ids.pop("")
257
257
        self._tree_id_paths.pop(old_root)
265
265
 
266
266
    def trans_id_tree_file_id(self, inventory_id):
267
267
        """Determine the transaction id of a working tree file.
268
 
        
 
268
 
269
269
        This reflects only files that already exist, not ones that will be
270
270
        added by transactions.
271
271
        """
335
335
        """Schedule creation of a new file.
336
336
 
337
337
        See also new_file.
338
 
        
 
338
 
339
339
        Contents is an iterator of strings, all of which will be written
340
340
        to the target destination.
341
341
 
404
404
 
405
405
    def create_directory(self, trans_id):
406
406
        """Schedule creation of a new directory.
407
 
        
 
407
 
408
408
        See also new_directory.
409
409
        """
410
410
        os.mkdir(self._limbo_name(trans_id))
535
535
 
536
536
    def final_kind(self, trans_id):
537
537
        """Determine the final file kind, after any changes applied.
538
 
        
 
538
 
539
539
        Raises NoSuchFile if the file does not exist/has no contents.
540
540
        (It is conceivable that a path would be created without the
541
541
        corresponding contents insertion command)
561
561
 
562
562
    def final_file_id(self, trans_id):
563
563
        """Determine the file id after any changes are applied, or None.
564
 
        
 
564
 
565
565
        None indicates that the file will not be versioned after changes are
566
566
        applied.
567
567
        """
606
606
 
607
607
    def by_parent(self):
608
608
        """Return a map of parent: children for known parents.
609
 
        
 
609
 
610
610
        Only new paths and parents of tree files with assigned ids are used.
611
611
        """
612
612
        by_parent = {}
613
613
        items = list(self._new_parent.iteritems())
614
 
        items.extend((t, self.final_parent(t)) for t in 
 
614
        items.extend((t, self.final_parent(t)) for t in
615
615
                      self._tree_id_paths.keys())
616
616
        for trans_id, parent_id in items:
617
617
            if parent_id not in by_parent:
652
652
        removed.  This is a necessary first step in detecting conflicts.
653
653
        """
654
654
        parents = self.by_parent().keys()
655
 
        parents.extend([t for t in self._removed_contents if 
 
655
        parents.extend([t for t in self._removed_contents if
656
656
                        self.tree_kind(t) == 'directory'])
657
657
        for trans_id in self._removed_id:
658
658
            file_id = self.tree_file_id(trans_id)
745
745
 
746
746
    def _improper_versioning(self):
747
747
        """Cannot version a file with no contents, or a bad type.
748
 
        
 
748
 
749
749
        However, existing entries with no contents are okay.
750
750
        """
751
751
        conflicts = []
761
761
 
762
762
    def _executability_conflicts(self):
763
763
        """Check for bad executability changes.
764
 
        
 
764
 
765
765
        Only versioned files may have their executability set, because
766
766
        1. only versioned entries can have executability under windows
767
767
        2. only files can be executable.  (The execute bit on a directory
936
936
            self.version_file(file_id, trans_id)
937
937
        return trans_id
938
938
 
939
 
    def new_file(self, name, parent_id, contents, file_id=None, 
 
939
    def new_file(self, name, parent_id, contents, file_id=None,
940
940
                 executable=None):
941
941
        """Convenience method to create files.
942
 
        
 
942
 
943
943
        name is the name of the file to create.
944
944
        parent_id is the transaction id of the parent directory of the file.
945
945
        contents is an iterator of bytestrings, which will be used to produce
965
965
        """
966
966
        trans_id = self._new_entry(name, parent_id, file_id)
967
967
        self.create_directory(trans_id)
968
 
        return trans_id 
 
968
        return trans_id
969
969
 
970
970
    def new_symlink(self, name, parent_id, target, file_id=None):
971
971
        """Convenience method to create symbolic link.
972
 
        
 
972
 
973
973
        name is the name of the symlink to create.
974
974
        parent_id is the transaction id of the parent directory of the symlink.
975
975
        target is a bytestring of the target of the symlink.
1999
1999
def build_tree(tree, wt, accelerator_tree=None, hardlink=False,
2000
2000
               delta_from_tree=False):
2001
2001
    """Create working tree for a branch, using a TreeTransform.
2002
 
    
 
2002
 
2003
2003
    This function should be used on empty trees, having a tree root at most.
2004
2004
    (see merge and revert functionality for working with existing trees)
2005
2005
 
2006
2006
    Existing files are handled like so:
2007
 
    
 
2007
 
2008
2008
    - Existing bzrdirs take precedence over creating new items.  They are
2009
2009
      created as '%s.diverted' % name.
2010
2010
    - Otherwise, if the content on disk matches the content we are building,
2241
2241
    if kind == 'file':
2242
2242
        contents = tree.get_file(entry.file_id).readlines()
2243
2243
        executable = tree.is_executable(entry.file_id)
2244
 
        return tt.new_file(name, parent_id, contents, entry.file_id, 
 
2244
        return tt.new_file(name, parent_id, contents, entry.file_id,
2245
2245
                           executable)
2246
2246
    elif kind in ('directory', 'tree-reference'):
2247
2247
        trans_id = tt.new_directory(name, parent_id, entry.file_id)
2248
2248
        if kind == 'tree-reference':
2249
2249
            tt.set_tree_reference(entry.reference_revision, trans_id)
2250
 
        return trans_id 
 
2250
        return trans_id
2251
2251
    elif kind == 'symlink':
2252
2252
        target = tree.get_symlink_target(entry.file_id)
2253
2253
        return tt.new_symlink(name, parent_id, target, entry.file_id)
2332
2332
        if entry.kind != working_kind:
2333
2333
            contents_mod, meta_mod = True, False
2334
2334
        else:
2335
 
            cur_entry._read_tree_state(working_tree.id2path(file_id), 
 
2335
            cur_entry._read_tree_state(working_tree.id2path(file_id),
2336
2336
                                       working_tree)
2337
2337
            contents_mod, meta_mod = entry.detect_changes(cur_entry)
2338
2338
            cur_entry._forget_tree_state()
2527
2527
                existing_file, new_file = conflict[1], conflict[2]
2528
2528
            new_name = tt.final_name(existing_file)+'.moved'
2529
2529
            tt.adjust_path(new_name, final_parent, existing_file)
2530
 
            new_conflicts.add((c_type, 'Moved existing file to', 
 
2530
            new_conflicts.add((c_type, 'Moved existing file to',
2531
2531
                               existing_file, new_file))
2532
2532
        elif c_type == 'parent loop':
2533
2533
            # break the loop by undoing one of the ops that caused the loop
2537
2537
            new_conflicts.add((c_type, 'Cancelled move', cur,
2538
2538
                               tt.final_parent(cur),))
2539
2539
            tt.adjust_path(tt.final_name(cur), tt.get_tree_parent(cur), cur)
2540
 
            
 
2540
 
2541
2541
        elif c_type == 'missing parent':
2542
2542
            trans_id = conflict[1]
2543
2543
            try:
2544
2544
                tt.cancel_deletion(trans_id)
2545
 
                new_conflicts.add(('deleting parent', 'Not deleting', 
 
2545
                new_conflicts.add(('deleting parent', 'Not deleting',
2546
2546
                                   trans_id))
2547
2547
            except KeyError:
2548
2548
                create = True
2613
2613
        if len(conflict) == 3:
2614
2614
            yield Conflict.factory(c_type, action=action, path=modified_path,
2615
2615
                                     file_id=modified_id)
2616
 
             
 
2616
 
2617
2617
        else:
2618
2618
            conflicting_path = fp.get_path(conflict[3])
2619
2619
            conflicting_id = tt.final_file_id(conflict[3])
2620
2620
            yield Conflict.factory(c_type, action=action, path=modified_path,
2621
 
                                   file_id=modified_id, 
 
2621
                                   file_id=modified_id,
2622
2622
                                   conflict_path=conflicting_path,
2623
2623
                                   conflict_file_id=conflicting_id)
2624
2624