/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/transform.py

• browse files at revision 6983
• compare with another revision
• compare with revision 1663
• download diff
• download tarball
• view history from revision 6983

Show diffs side-by-side

added

removed

breezy/transform.py

1119

1119

                                      (('attribs',),))

1120

1120

        for trans_id, kind in viewitems(self._new_contents):

1121

1121

            if kind == 'file':

1122

 

                lines = osutils.chunks_to_lines(

1123

 

                    self._read_file_chunks(trans_id))

 

1122

                with open(self._limbo_name(trans_id), 'rb') as cur_file:

 

1123

                    lines = cur_file.readlines()

1124

1124

                parents = self._get_parents_lines(trans_id)

1125

1125

                mpdiff = multiparent.MultiParent.from_lines(lines, parents)

1126

 

                content = ''.join(mpdiff.to_patch())

 

1126

                content = b''.join(mpdiff.to_patch())

1127

1127

            if kind == 'directory':

1128

 

                content = ''

 

1128

                content = b''

1129

1129

            if kind == 'symlink':

1130

1130

                content = self._read_symlink_target(trans_id)

1131

1131

            yield serializer.bytes_record(content, ((trans_id, kind),))

1310

1310

            We can use it to prevent future sha1 computations.

1311

1311

        """

1312

1312

        name = self._limbo_name(trans_id)

1313

 

        f = open(name, 'wb')

1314

 

        try:

 

1313

        with open(name, 'wb') as f:

1315

1314

            unique_add(self._new_contents, trans_id, 'file')

1316

1315

            f.writelines(contents)

1317

 

        finally:

1318

 

            f.close()

1319

1316

        self._set_mtime(name)

1320

1317

        self._set_mode(trans_id, mode_id, S_ISREG)

1321

1318

        # It is unfortunate we have to use lstat instead of fstat, but we just

1324

1321

        if sha1 is not None:

1325

1322

            self._observed_sha1s[trans_id] = (sha1, osutils.lstat(name))

1326

1323

 

1327

 

    def _read_file_chunks(self, trans_id):

1328

 

        cur_file = open(self._limbo_name(trans_id), 'rb')

1329

 

        try:

1330

 

            return cur_file.readlines()

1331

 

        finally:

1332

 

            cur_file.close()

1333

 

 

1334

1324

    def _read_symlink_target(self, trans_id):

1335

1325

        return os.readlink(self._limbo_name(trans_id))

1336

1326

 

2265

2255

        if kind is None:

2266

2256

            return self._transform._tree.get_file_verifier(path, file_id)

2267

2257

        if kind == 'file':

2268

 

            fileobj = self.get_file(path, file_id)

2269

 

            try:

 

2258

            with self.get_file(path, file_id) as fileobj:

2270

2259

                return ("SHA1", sha_file(fileobj))

2271

 

            finally:

2272

 

                fileobj.close()

2273

2260

 

2274

2261

    def get_file_sha1(self, path, file_id=None, stat_value=None):

2275

2262

        trans_id = self._path2trans_id(path)

2279

2266

        if kind is None:

2280

2267

            return self._transform._tree.get_file_sha1(path, file_id)

2281

2268

        if kind == 'file':

2282

 

            fileobj = self.get_file(path, file_id)

2283

 

            try:

 

2269

            with self.get_file(path, file_id) as fileobj:

2284

2270

                return sha_file(fileobj)

2285

 

            finally:

2286

 

                fileobj.close()

2287

2271

 

2288

2272

    def is_executable(self, path, file_id=None):

2289

2273

        trans_id = self._path2trans_id(path)

2678

2662

                tt.create_hardlink(accelerator_tree.abspath(accelerator_path),

2679

2663

                                   trans_id)

2680

2664

            else:

2681

 

                contents = accelerator_tree.get_file(accelerator_path, file_id)

2682

 

                if wt.supports_content_filtering():

2683

 

                    filters = wt._content_filter_stack(tree_path)

2684

 

                    contents = filtered_output_bytes(contents, filters,

2685

 

                        ContentFilterContext(tree_path, tree))

2686

 

                try:

2687

 

                    tt.create_file(contents, trans_id, sha1=text_sha1)

2688

 

                finally:

2689

 

                    try:

2690

 

                        contents.close()

2691

 

                    except AttributeError:

2692

 

                        # after filtering, contents may no longer be file-like

2693

 

                        pass

 

2665

                with accelerator_tree.get_file(accelerator_path, file_id) as f:

 

2666

                    chunks = osutils.file_iterator(f)

 

2667

                    if wt.supports_content_filtering():

 

2668

                        filters = wt._content_filter_stack(tree_path)

 

2669

                        chunks = filtered_output_bytes(chunks, filters,

 

2670

                            ContentFilterContext(tree_path, tree))

 

2671

                    tt.create_file(chunks, trans_id, sha1=text_sha1)

2694

2672

            count += 1

2695

2673

        offset += count

2696

2674

    for count, ((trans_id, file_id, tree_path, text_sha1), contents) in enumerate(

2721

2699

    if entry.kind == "directory":

2722

2700

        return True

2723

2701

    if entry.kind == "file":

2724

 

        f = file(target_path, 'rb')

2725

 

        try:

2726

 

            if tree.get_file_text(tree_path, file_id) == f.read():

 

2702

        with open(target_path, 'rb') as f1, \

 

2703

             tree.get_file(tree_path, file_id) as f2:

 

2704

            if osutils.compare_files(f1, f2):

2727

2705

                return True

2728

 

        finally:

2729

 

            f.close()

2730

2706

    elif entry.kind == "symlink":

2731

2707

        if tree.get_symlink_target(tree_path, file_id) == os.readlink(target_path):

2732

2708

            return True

2768

2744

    name = entry.name

2769

2745

    kind = entry.kind

2770

2746

    if kind == 'file':

2771

 

        contents = tree.get_file(path, entry.file_id).readlines()

2772

 

        executable = tree.is_executable(path, entry.file_id)

2773

 

        return tt.new_file(name, parent_id, contents, entry.file_id,

2774

 

                           executable)

 

2747

        with tree.get_file(path, entry.file_id) as f:

 

2748

            executable = tree.is_executable(path, entry.file_id)

 

2749

            return tt.new_file(

 

2750

                    name, parent_id, osutils.file_iterator(f), entry.file_id,

 

2751

                    executable)

2775

2752

    elif kind in ('directory', 'tree-reference'):

2776

2753

        trans_id = tt.new_directory(name, parent_id, entry.file_id)

2777

2754

        if kind == 'tree-reference':

2784

2761

        raise errors.BadFileKindError(name, kind)

2785

2762

 

2786

2763

 

2787

 

def create_from_tree(tt, trans_id, tree, path, file_id=None, bytes=None,

 

2764

def create_from_tree(tt, trans_id, tree, path, file_id=None, chunks=None,

2788

2765

    filter_tree_path=None):

2789

2766

    """Create new file contents according to tree contents.

2790

2767

 

2796

2773

    if kind == 'directory':

2797

2774

        tt.create_directory(trans_id)

2798

2775

    elif kind == "file":

2799

 

        if bytes is None:

2800

 

            tree_file = tree.get_file(path, file_id)

2801

 

            try:

2802

 

                bytes = tree_file.readlines()

2803

 

            finally:

2804

 

                tree_file.close()

2805

 

        wt = tt._tree

2806

 

        if wt.supports_content_filtering() and filter_tree_path is not None:

2807

 

            filters = wt._content_filter_stack(filter_tree_path)

2808

 

            bytes = filtered_output_bytes(bytes, filters,

2809

 

                ContentFilterContext(filter_tree_path, tree))

2810

 

        tt.create_file(bytes, trans_id)

 

2776

        if chunks is None:

 

2777

            f = tree.get_file(path, file_id)

 

2778

            chunks = osutils.file_iterator(f)

 

2779

        else:

 

2780

            f = None

 

2781

        try:

 

2782

            wt = tt._tree

 

2783

            if wt.supports_content_filtering() and filter_tree_path is not None:

 

2784

                filters = wt._content_filter_stack(filter_tree_path)

 

2785

                chunks = filtered_output_bytes(chunks, filters,

 

2786

                    ContentFilterContext(filter_tree_path, tree))

 

2787

            tt.create_file(chunks, trans_id)

 

2788

        finally:

 

2789

            if f is not None:

 

2790

                f.close()

2811

2791

    elif kind == "symlink":

2812

2792

        tt.create_symlink(tree.get_symlink_target(path, file_id), trans_id)

2813

2793

    else:

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0