示例#1
0
 def test_add(self):
     myhexsha = b'd80c186a03f423a81b39df39dc87fd269736ca86'
     x = Tree()
     x.add(b'myname', 0o100755, myhexsha)
     self.assertEqual(x[b'myname'], (0o100755, myhexsha))
     self.assertEqual(b'100755 myname\0' + hex_to_sha(myhexsha),
             x.as_raw_string())
示例#2
0
    def test_commit_with_change(self):
        a = Blob.from_string(b"The Foo\n")
        ta = Tree()
        ta.add(b"somename", 0o100644, a.id)
        ca = make_commit(tree=ta.id)
        b = Blob.from_string(b"The Bar\n")
        tb = Tree()
        tb.add(b"somename", 0o100644, b.id)
        cb = make_commit(tree=tb.id, parents=[ca.id])
        self.repo.object_store.add_objects(
            [(a, None), (b, None), (ta, None), (tb, None),
             (ca, None), (cb, None)])
        outstream = StringIO()
        porcelain.show(self.repo.path, objects=[cb.id], outstream=outstream)
        self.assertMultiLineEqual(outstream.getvalue(), """\
--------------------------------------------------
commit: 2c6b6c9cb72c130956657e1fdae58e5b103744fa
Author: Test Author <*****@*****.**>
Committer: Test Committer <*****@*****.**>
Date:   Fri Jan 01 2010 00:00:00 +0000

Test message.

diff --git a/somename b/somename
index ea5c7bf..fd38bcb 100644
--- a/somename
+++ b/somename
@@ -1 +1 @@
-The Foo
+The Bar
""")
示例#3
0
文件: bills.py 项目: VersaHQ/billy
def git_repo_init(gitdir):
    os.mkdir(gitdir)
    repo = Repo.init_bare(gitdir)
    blob = Blob.from_string("""Why, Hello there!

This is your friendly Legislation tracker, Billy here.

This is a git repo full of everything I write to the DB. This isn't super
useful unless you're debugging production issues.

Fondly,
   Bill, your local Billy instance.""")
    tree = Tree()
    tree.add("README", 0100644, blob.id)
    commit = Commit()
    commit.tree = tree.id
    author = "Billy <billy@localhost>"
    commit.author = commit.committer = author
    commit.commit_time = commit.author_time = int(time())
    tz = parse_timezone('-0400')[0]
    commit.commit_timezone = commit.author_timezone = tz
    commit.encoding = "UTF-8"
    commit.message = "Initial commit"
    repo.object_store.add_object(blob)
    repo.object_store.add_object(tree)
    repo.object_store.add_object(commit)
    repo.refs['refs/heads/master'] = commit.id
示例#4
0
 def test_add(self):
     myhexsha = "d80c186a03f423a81b39df39dc87fd269736ca86"
     x = Tree()
     x.add("myname", 0100755, myhexsha)
     self.assertEquals(x["myname"], (0100755, myhexsha))
     self.assertEquals('100755 myname\0' + hex_to_sha(myhexsha),
             x.as_raw_string())
示例#5
0
    def test_emit_commit(self):
        b = Blob()
        b.data = "FOO"
        t = Tree()
        t.add(stat.S_IFREG | 0644, "foo", b.id)
        c = Commit()
        c.committer = c.author = "Jelmer <jelmer@host>"
        c.author_time = c.commit_time = 1271345553
        c.author_timezone = c.commit_timezone = 0
        c.message = "msg"
        c.tree = t.id
        self.store.add_objects([(b, None), (t, None), (c, None)])
        self.fastexporter.emit_commit(c, "refs/heads/master")
        self.assertEquals("""blob
mark :1
data 3
FOO
commit refs/heads/master
mark :2
author Jelmer <jelmer@host> 1271345553 +0000
committer Jelmer <jelmer@host> 1271345553 +0000
data 3
msg
M 644 1 foo
""", self.stream.getvalue())
示例#6
0
文件: db.py 项目: mbr/qwapp
	def _update_file(self, name, subdir, filename, data, commit_msg):
		# first, create a new blob for the data
		blob = Blob.from_string(data.encode('utf-8'))

		# fetch the old tree object, add new page
		try:
			subdir_tree = _walk_git_repo_tree(self.repo, self.current_tree, subdir)
		except KeyError:
			# we need to create the subdir_tree as well, since it does not exist
			# yet
			subdir_tree = Tree()
		subdir_tree.add(_git_default_file_mode, filename, blob.id)

		# create new root tree
		tree = self.current_tree
		tree.add(stat.S_IFDIR, subdir, subdir_tree.id)

		# create commit
		commit = Commit()
		commit.parents = [self.current_commit.id]
		commit.tree = tree.id
		commit.author = commit.committer = self.wiki_user
		commit.commit_time =  commit.author_time = int(time.time())
		commit.commit_timezone = commit.author_timezone = parse_timezone(time.timezone)[0]
		commit.encoding = 'UTF-8'
		commit.message = commit_msg.encode('utf-8')

		# store all objects
		self.repo.object_store.add_object(blob)
		self.repo.object_store.add_object(subdir_tree)
		self.repo.object_store.add_object(tree)
		self.repo.object_store.add_object(commit)

		# update the branch
		self.repo.refs[self.head] = commit.id
示例#7
0
def create_commit(data, marker='Default', blob=None):
    if not blob:
        blob = Blob.from_string('The blob content %s' % marker)
    tree = Tree()
    tree.add("thefile_%s" % marker, 0o100644, blob.id)
    cmt = Commit()
    if data:
        assert isinstance(data[-1], Commit)
        cmt.parents = [data[-1].id]
    cmt.tree = tree.id
    author = "John Doe %s <*****@*****.**>" % marker
    cmt.author = cmt.committer = author
    tz = parse_timezone('-0200')[0]
    cmt.commit_time = cmt.author_time = int(time())
    cmt.commit_timezone = cmt.author_timezone = tz
    cmt.encoding = "UTF-8"
    cmt.message = "The commit message %s" % marker
    tag = Tag()
    tag.tagger = "*****@*****.**"
    tag.message = "Annotated tag"
    tag.tag_timezone = parse_timezone('-0200')[0]
    tag.tag_time = cmt.author_time
    tag.object = (Commit, cmt.id)
    tag.name = "v_%s_0.1" % marker
    return blob, tree, tag, cmt
示例#8
0
文件: gittle.py 项目: rubik/gittle
    def _tree_from_structure(self, structure):
        # TODO : Support directories
        tree = Tree()

        for file_info in structure:

            # str only
            try:
                data = file_info["data"].encode("ascii")
                name = file_info["name"].encode("ascii")
                mode = file_info["mode"]
            except:
                # Skip file on encoding errors
                continue

            blob = Blob()

            blob.data = data

            # Store file's contents
            self.repo.object_store.add_object(blob)

            # Add blob entry
            tree.add(name, mode, blob.id)

        # Store tree
        self.repo.object_store.add_object(tree)

        return tree.id
示例#9
0
文件: start.py 项目: Swizec/OS2
def init_the_git(config):
    path = config.get('Local', 'path')

    repo = Repo.init(path)
    blob = Blob.from_string(open(os.path.join(path, '.git-dropbox.cnf')).read())

    tree = Tree()
    tree.add(".git-dropbox.cnf", 0100644, blob.id)

    commit = Commit()
    commit.tree = tree.id
    commit.author = config.get('Local', 'user')
    commit.committer = 'Git-dropbox'
    commit.commit_time = int(time())
    commit.author_time = os.path.getctime(os.path.join(path, '.git-dropbox.cnf'))
    commit.commit_timezone = commit.author_timezone = parse_timezone('-0200')[0]
    commit.encoding = 'UTF-8'
    commit.message = 'Initial commit'

    object_store = repo.object_store
    object_store.add_object(blob)
    object_store.add_object(tree)
    object_store.add_object(commit)

    repo.refs['refs/heads/master'] = commit.id
示例#10
0
文件: logsave.py 项目: ekeijl/BeAT
def __init_code__():
	# initialize the repo if it doesn't exists, or load it if it does

	if not path.exists(LOGS_PATH):
		print "creating folder "+ LOGS_PATH
		mkdir(LOGS_PATH)
		repo = Repo.init(LOGS_PATH)
		blob = Blob.from_string("data")
		tree =Tree()
		tree.add(0100644, "initfile", blob.id)
		c = Commit()
		c.tree = tree.id
		author = "Writer [email protected]"
		c.author=c.committer=author
		c.commit_time=c.author_time=int(time())
		tz = parse_timezone('+0200')
		c.commit_timezone=c.author_timezone=tz
		c.encoding="UTF-8"
		c.message="initial commit"
		store = repo.object_store
		store.add_object(blob)
		store.add_object(tree)
		store.add_object(c)
		repo.refs['refs/heads/master'] = c.id
		repo.refs['HEAD'] = 'ref: refs/heads/master'
		print "success!"
	else:
		#this is how to create a Repo object from an existing repository
		from dulwich.errors import NotGitRepository
		try:
			repo = Repo(LOGS_PATH)
		except NotGitRepository as e:
			raise GitFileError("Error: the path %s exists but is not a git repository."%LOGS_PATH)
	return repo
示例#11
0
    def test_commit_no_parent(self):
        a = Blob.from_string(b"The Foo\n")
        ta = Tree()
        ta.add(b"somename", 0o100644, a.id)
        ca = make_commit(tree=ta.id)
        self.repo.object_store.add_objects([(a, None), (ta, None), (ca, None)])
        outstream = StringIO()
        porcelain.show(self.repo.path, objects=[ca.id], outstream=outstream)
        self.assertMultiLineEqual(outstream.getvalue(), """\
--------------------------------------------------
commit: 344da06c1bb85901270b3e8875c988a027ec087d
Author: Test Author <*****@*****.**>
Committer: Test Committer <*****@*****.**>
Date:   Fri Jan 01 2010 00:00:00 +0000

Test message.

diff --git /dev/null b/somename
new mode 100644
index 0000000..ea5c7bf 100644
--- /dev/null
+++ b/somename
@@ -0,0 +1 @@
+The Foo
""")
示例#12
0
 def test_full_tree(self):
     c = self.make_commit(commit_time=30)
     t = Tree()
     t.add(b'data-x', 0o644, Blob().id)
     c.tree = t
     c1 = Commit()
     c1.set_raw_string(c.as_raw_string())
     self.assertEqual(t.id, c1.tree)
     self.assertEqual(c.as_raw_string(), c1.as_raw_string())
示例#13
0
def create_repo(design, initialize):
    full_path = os.path.join(settings.GIT_ROOT, design.repo_path)
    os.makedirs(full_path)
    repo = Repo.init_bare(full_path)
    if initialize:
        blob = Blob.from_string(str("%s Git-a-thing design repository\n" % design.name))
        tree = Tree()
        tree.add("README", 0100644, blob.id)
        do_commit(repo, tree, [blob], "Initialize repository", settings.GITATHING_COMMITER)
示例#14
0
 def write_git_tree(self):
     git_tree = GitTree()
     for key, entry in self._entries:
         git_tree.add(
             name=key,
             mode=entry.mode,
             hexsha=entry.sha,
         )
     self._git_store.add_object(git_tree)
     return git_tree.id
示例#15
0
 def test_git_dir(self):
     obj = Tree()
     a = Blob()
     a.data = b"foo"
     obj.add(b".git", 0o100644, a.id)
     self.repo.object_store.add_objects(
         [(a, None), (obj, None)])
     self.assertEqual(
             [(obj.id, 'invalid name .git')],
             [(sha, str(e)) for (sha, e) in porcelain.fsck(self.repo)])
示例#16
0
 def _get_example_tar_stream(self, *tar_stream_args, **tar_stream_kwargs):
     store = MemoryObjectStore()
     b1 = Blob.from_string(b"somedata")
     store.add_object(b1)
     t1 = Tree()
     t1.add(b"somename", 0o100644, b1.id)
     store.add_object(t1)
     stream = b''.join(
         tar_stream(store, t1, *tar_stream_args, **tar_stream_kwargs))
     return BytesIO(stream)
示例#17
0
 def test_add_old_order(self):
     myhexsha = "d80c186a03f423a81b39df39dc87fd269736ca86"
     x = Tree()
     warnings.simplefilter("ignore", DeprecationWarning)
     try:
         x.add(0100755, "myname", myhexsha)
     finally:
         warnings.resetwarnings()
     self.assertEqual(x["myname"], (0100755, myhexsha))
     self.assertEqual("100755 myname\0" + hex_to_sha(myhexsha), x.as_raw_string())
示例#18
0
 def build_tree(path):
     tree = Tree()
     for basename, entry in trees[path].iteritems():
         if type(entry) == dict:
             mode = stat.S_IFDIR
             sha = build_tree(os.path.join(path, basename))
         else:
             (mode, sha) = entry
         tree.add(mode, basename, sha)
     object_store.add_object(tree)
     return tree.id
示例#19
0
文件: index.py 项目: s-m-b/dulwich
 def build_tree(path):
     tree = Tree()
     for basename, entry in trees[path].items():
         if isinstance(entry, dict):
             mode = stat.S_IFDIR
             sha = build_tree(pathjoin(path, basename))
         else:
             (mode, sha) = entry
         tree.add(basename, mode, sha)
     object_store.add_object(tree)
     return tree.id
示例#20
0
文件: __init__.py 项目: mbr/gittar
    def store_tree(node):
        tree = Tree()

        for name in node:
            if isinstance(node[name], dict):
                tree.add(name.encode(args.encoding),
                         MODE_TREE, store_tree(node[name]).id)
            else:
                tree.add(name.encode(args.encoding), *node[name])

        repo.object_store.add_object(tree)
        return tree
示例#21
0
 def test_simple(self):
     store = MemoryObjectStore()
     b1 = Blob.from_string(b"somedata")
     store.add_object(b1)
     t1 = Tree()
     t1.add(b"somename", 0o100644, b1.id)
     store.add_object(t1)
     stream = b''.join(tar_stream(store, t1, 10))
     out = BytesIO(stream)
     tf = tarfile.TarFile(fileobj=out)
     self.addCleanup(tf.close)
     self.assertEqual(["somename"], tf.getnames())
示例#22
0
def create_commit(marker=None):
    blob = Blob.from_string('The blob content %s' % marker)
    tree = Tree()
    tree.add("thefile %s" % marker, 0o100644, blob.id)
    cmt = Commit()
    cmt.tree = tree.id
    cmt.author = cmt.committer = "John Doe <*****@*****.**>"
    cmt.message = "%s" % marker
    tz = parse_timezone('-0200')[0]
    cmt.commit_time = cmt.author_time = int(time.time())
    cmt.commit_timezone = cmt.author_timezone = tz
    return cmt, tree, blob
示例#23
0
 def compute_tree_hash(dirname):
     tree = Tree()
     for entry in sorted(os.listdir(dirname)):
         fname = os.path.join(dirname, entry)
         if os.path.isdir(fname):
             thash = GitRepo.compute_tree_hash(fname)
             mode = stat.S_IFDIR # os.stat(fname)[stat.ST_MODE]
             tree.add(entry, mode, thash)
         elif os.path.isfile(fname):
             bhash = GitRepo.compute_blob_hash(fname)
             mode = os.stat(fname)[stat.ST_MODE]
             tree.add(entry, mode, bhash)
     return tree.id
示例#24
0
    def test_tree_copy_after_update(self):
        """Check Tree.id is correctly updated when the tree is copied after updated.
        """
        shas = []
        tree = Tree()
        shas.append(tree.id)
        tree.add(b'data', 0o644, Blob().id)
        copied = tree.copy()
        shas.append(tree.id)
        shas.append(copied.id)

        self.assertNotIn(shas[0], shas[1:])
        self.assertEqual(shas[1], shas[2])
示例#25
0
 def test_simple(self):
     c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
         [3, 1, 2]])
     b = Blob()
     b.data = b"foo the bar"
     t = Tree()
     t.add(b"somename", 0o100644, b.id)
     self.repo.object_store.add_object(t)
     self.repo.object_store.add_object(b)
     sha = porcelain.commit_tree(
         self.repo.path, t.id, message=b"Withcommit.",
         author=b"Joe <*****@*****.**>",
         committer=b"Jane <*****@*****.**>")
     self.assertTrue(isinstance(sha, bytes))
     self.assertEqual(len(sha), 40)
示例#26
0
def tree_from_dir(repo, dirname):
    abspath = os.path.abspath(dirname)
    tree = Tree()
    for name in os.listdir(dirname):
        path = os.path.join(abspath, name)
        s = os.lstat(path)
        mode = s.st_mode
        if S_ISDIR(mode):
            obj = tree_from_dir(repo, path)
        else:
            obj = Blob.from_string(file(path).read())
        repo.object_store.add_object(obj)
        tree.add(name, mode, obj.id)

    repo.object_store.add_object(tree)
    return tree
示例#27
0
        def savedir(dirname):
            tree = Tree()
            names = dirs[dirname]

            for name in names:
                basename = os.path.basename(name)
                sha = blobs.get(name, None)

                if sha is not None:
                    tree.add(basename.encode('utf-8'), 0100644, sha)
                    continue

                subtree = savedir(name)
                tree.add(basename.encode('utf-8'), 040000, subtree.id)

            repo.object_store.add_object(tree)
            return tree
示例#28
0
def initial_commit(repo):
    # Add file content
    blob = Blob.from_string("My file content\n")
    # Add file
    tree = Tree()
    tree.add(0100644, "spam", blob.id)
    # Set commit
    commit = make_commit(repo, tree.id, "Initial commit")
    # Initial commit
    object_store = repo.object_store
    object_store.add_object(blob)
    object_store.add_object(tree)
    object_store.add_object(commit)
    # Update master
    update_master(repo, commit.id)
    # Set the master branch as the default
    repo.refs['HEAD'] = 'ref: refs/heads/master'
示例#29
0
def setup_app(command, conf, vars):
    """Place any commands to setup kekswiki here"""
    # Don't reload the app if it was loaded under the testing environment
    if not pylons.test.pylonsapp:
        load_environment(conf.global_conf, conf.local_conf)

    # create repository directory
    try:
        mkdir("wiki")
    except OSError:
        pass

    # create repository
    try:
        repo = Repo.init("wiki")
    except OSError:
        repo = Repo("wiki")

    # create blob
    blob = Blob.from_string("Kekswiki is a collaborative hypertext editing system.\n")

    # add blob to tree
    tree = Tree()
    tree.add(0100644, "Kekswiki", blob.id)

    # commit
    commit = Commit()
    commit.tree = tree.id
    author = "Anonymous <*****@*****.**>"
    commit.author = commit.committer = author
    commit.commit_time = commit.author_time = int(time())
    tz = parse_timezone('+0100')[0]  # FIXME: get proper timezone
    commit.commit_timezone = commit.author_timezone = tz
    commit.encoding = "UTF-8"
    commit.message = "Initial commit"

    # save everything
    object_store = repo.object_store
    object_store.add_object(blob)
    object_store.add_object(tree)
    object_store.add_object(commit)

    # create master branch, set it as current
    repo.refs.add_if_new('refs/heads/master', commit.id)
    repo.refs.set_symbolic_ref('HEAD', 'refs/heads/master')
示例#30
0
    def _dulwich_tag(self, tag, author, message=None):
        """ Creates a tag in git via dulwich calls:

                **tag** - string :: "<project>-[start|sync]-<timestamp>"
                **author** - string :: "Your Name <*****@*****.**>"
        """
        if not message:
            message = tag

        # Open the repo
        _repo = Repo(self.config['top_dir'])
        master_branch = 'master'

        # Build the commit object
        blob = Blob.from_string("empty")
        tree = Tree()
        tree.add(tag, 0100644, blob.id)

        commit = Commit()
        commit.tree = tree.id
        commit.author = commit.committer = author
        commit.commit_time = commit.author_time = int(time())
        tz = parse_timezone('-0200')[0]
        commit.commit_timezone = commit.author_timezone = tz
        commit.encoding = "UTF-8"
        commit.message = 'Tagging repo for deploy: ' + message

        # Add objects to the repo store instance
        object_store = _repo.object_store
        object_store.add_object(blob)
        object_store.add_object(tree)
        object_store.add_object(commit)
        _repo.refs['refs/heads/' + master_branch] = commit.id

        # Build the tag object and tag
        tag = Tag()
        tag.tagger = author
        tag.message = message
        tag.name = tag
        tag.object = (Commit, commit.id)
        tag.tag_time = commit.author_time
        tag.tag_timezone = tz
        object_store.add_object(tag)
        _repo['refs/tags/' + tag] = tag.id
示例#31
0
 def test_tree_diff_submodule(self):
     f = BytesIO()
     store = MemoryObjectStore()
     tree1 = Tree()
     tree1.add(b"asubmodule", S_IFGITLINK,
               b"06d0bdd9e2e20377b3180e4986b14c8549b393e4")
     tree2 = Tree()
     tree2.add(b"asubmodule", S_IFGITLINK,
               b"cc975646af69f279396d4d5e1379ac6af80ee637")
     store.add_objects([(o, None) for o in [tree1, tree2]])
     write_tree_diff(f, store, tree1.id, tree2.id)
     self.assertEqual([
         b'diff --git a/asubmodule b/asubmodule',
         b'index 06d0bdd..cc97564 160000',
         b'--- a/asubmodule',
         b'+++ b/asubmodule',
         b'@@ -1 +1 @@',
         b'-Submodule commit 06d0bdd9e2e20377b3180e4986b14c8549b393e4',
         b'+Submodule commit cc975646af69f279396d4d5e1379ac6af80ee637',
         ], f.getvalue().splitlines())
示例#32
0
 def test_import_tree_with_file_exe(self):
     blob = Blob.from_string(b"bar")
     tree = Tree()
     tree.add(b"foo", 0o100755, blob.id)
     objects = {blob.id: blob, tree.id: tree}
     ret, child_modes = import_git_tree(
         self._texts, self._mapping, b"", b"", (None, tree.id), None, None,
         b"somerevid", [], objects.__getitem__, (None, stat.S_IFDIR),
         DummyStoreUpdater(), self._mapping.generate_file_id)
     self.assertEqual(child_modes, {})
     self.assertEqual(2, len(ret))
     self.assertEqual(None, ret[0][0])
     self.assertEqual("", ret[0][1])
     self.assertEqual(None, ret[1][0])
     self.assertEqual("foo", ret[1][1])
     ie = ret[0][3]
     self.assertEqual("directory", ie.kind)
     ie = ret[1][3]
     self.assertEqual("file", ie.kind)
     self.assertEqual(True, ie.executable)
示例#33
0
 def build_tree(path):
     if path:
         tree = self._get_object(path,
                                 branch=branch,
                                 commit_sha=commit_sha)
         if not tree:
             tree = Tree()
         if not isinstance(tree, Tree):
             self.delete(path, branch=branch)
             tree = Tree()
     else:
         tree = root_tree
     for basename, entry in trees[path].iteritems():
         if type(entry) == dict:
             mode = stat.S_IFDIR
             sha = build_tree(pathjoin(path, basename))
         else:
             (mode, sha) = entry
         tree.add(basename, mode, sha)
     self.repo.object_store.add_object(tree)
     return tree.id
示例#34
0
 def test_versioned_replace_by_dir(self):
     self.build_tree(['a'])
     self.wt.add(['a'])
     self.wt.commit('')
     os.unlink('a')
     os.mkdir('a')
     olda = Blob.from_string(b'contents of a\n')
     oldt = Tree()
     oldt.add(b"a", stat.S_IFREG | 0o644, olda.id)
     newt = Tree()
     newa = Tree()
     newt.add(b"a", stat.S_IFDIR, newa.id)
     self.expectDelta([((b'', b''), (stat.S_IFDIR, stat.S_IFDIR),
                        (oldt.id, newt.id)),
                       ((b'a', b'a'), (stat.S_IFREG | 0o644, stat.S_IFDIR),
                        (olda.id, newa.id))],
                      want_unversioned=False)
     self.expectDelta([((b'', b''), (stat.S_IFDIR, stat.S_IFDIR),
                        (oldt.id, newt.id)),
                       ((b'a', b'a'), (stat.S_IFREG | 0o644, stat.S_IFDIR),
                        (olda.id, newa.id))],
                      want_unversioned=True)
示例#35
0
 def test_import_tree_with_file(self):
     blob = Blob.from_string(b"bar1")
     tree = Tree()
     tree.add(b"foo", stat.S_IFREG | 0o644, blob.id)
     objects = {blob.id: blob, tree.id: tree}
     ret, child_modes = import_git_tree(
         self._texts, self._mapping, b"bla", b"bla", (None, tree.id), None,
         None, b"somerevid", [], objects.__getitem__, (None, stat.S_IFDIR),
         DummyStoreUpdater(), self._mapping.generate_file_id)
     self.assertEqual(child_modes, {})
     self.assertEqual(2, len(ret))
     self.assertEqual(None, ret[0][0])
     self.assertEqual("bla", ret[0][1])
     self.assertEqual(None, ret[1][0])
     self.assertEqual("bla/foo", ret[1][1])
     ie = ret[0][3]
     self.assertEqual("directory", ie.kind)
     ie = ret[1][3]
     self.assertEqual("file", ie.kind)
     self.assertEqual(b"git:bla/foo", ie.file_id)
     self.assertEqual(b"somerevid", ie.revision)
     self.assertEqual(osutils.sha_strings([b"bar1"]), ie.text_sha1)
     self.assertEqual(False, ie.executable)
示例#36
0
 def test_directory_converted_to_submodule(self):
     base_inv = Inventory()
     base_inv.add_path("foo", "directory")
     base_inv.add_path("foo/bar", "file")
     othertree = Blob.from_string(b"someotherthing")
     blob = Blob.from_string(b"bar")
     tree = Tree()
     tree.add(b"bar", 0o160000, blob.id)
     objects = {tree.id: tree}
     ret, child_modes = import_git_submodule(
         self._texts, self._mapping, b"foo", b"foo",
         (tree.id, othertree.id), base_inv, base_inv.root.file_id,
         b"somerevid", [],
         objects.__getitem__, (stat.S_IFDIR | 0o755, S_IFGITLINK),
         DummyStoreUpdater(), self._mapping.generate_file_id)
     self.assertEqual(child_modes, {})
     self.assertEqual(2, len(ret))
     self.assertEqual(ret[0],
                      ("foo/bar", None, base_inv.path2id("foo/bar"), None))
     self.assertEqual(ret[1][:3],
                      ("foo", "foo", self._mapping.generate_file_id("foo")))
     ie = ret[1][3]
     self.assertEqual(ie.kind, "tree-reference")
示例#37
0
    def write(self, data):
        commit = Commit()

        # commit metadata
        author = b"tinydb"
        commit.author = commit.committer = author
        commit.commit_time = commit.author_time = int(time.time())
        tz = time.timezone if (time.localtime().tm_isdst) else time.altzone
        commit.commit_timezone = commit.author_timezone = tz
        commit.encoding = b'UTF-8'
        commit.message = (
            'Updated by tinydb-git {}'.format(__version__).encode('utf8'))

        # prepare blob
        blob = Blob.from_string(self._serialize(data))

        try:
            parent_commit = self.repo[self._refname]
        except KeyError:
            # branch does not exist, start with an empty tree
            tree = Tree()
        else:
            commit.parents = [parent_commit.id]
            tree = self.repo[parent_commit.tree]

        # no subdirs in filename, add directly to tree
        tree.add(self.filename, 0o100644, blob.id)

        commit.tree = tree.id

        # add objects
        self.repo.object_store.add_object(blob)
        self.repo.object_store.add_object(tree)
        self.repo.object_store.add_object(commit)

        # update refs
        self.repo.refs[self._refname] = commit.id
示例#38
0
    def test_copied_file(self):
        self.build_tree(['a'])
        self.wt.add(['a'])
        self.wt.copy_one('a', 'b')
        a = Blob.from_string(b'contents of a\n')
        self.store.add_object(a)
        oldt = Tree()
        oldt.add(b"a", stat.S_IFREG | 0o644, a.id)
        self.store.add_object(oldt)
        newt = Tree()
        newt.add(b"a", stat.S_IFREG | 0o644, a.id)
        newt.add(b"b", stat.S_IFREG | 0o644, a.id)
        self.store.add_object(newt)
        self.expectDelta([
            ('modify', (b'', stat.S_IFDIR, oldt.id),
             (b'', stat.S_IFDIR, newt.id)),
            ('add', (None, None, None), (b'b', stat.S_IFREG | 0o644, a.id)),
        ],
                         tree_id=oldt.id)

        if dulwich_version >= (0, 19, 15):
            self.expectDelta([('modify', (b'', stat.S_IFDIR, oldt.id),
                               (b'', stat.S_IFDIR, newt.id)),
                              ('copy', (b'a', stat.S_IFREG | 0o644, a.id),
                               (b'b', stat.S_IFREG | 0o644, a.id))],
                             tree_id=oldt.id,
                             rename_detector=RenameDetector(
                                 self.store, find_copies_harder=True))
            self.expectDelta([
                ('modify', (b'', stat.S_IFDIR, oldt.id),
                 (b'', stat.S_IFDIR, newt.id)),
                ('add', (None, None, None),
                 (b'b', stat.S_IFREG | 0o644, a.id)),
            ],
                             tree_id=oldt.id,
                             rename_detector=RenameDetector(
                                 self.store, find_copies_harder=False))
示例#39
0
    def _update_file(self, name, subdir, filename, data, commit_msg):
        # first, create a new blob for the data
        blob = Blob.from_string(data.encode('utf-8'))

        # fetch the old tree object, add new page
        try:
            subdir_tree = _walk_git_repo_tree(self.repo, self.current_tree,
                                              subdir)
        except KeyError:
            # we need to create the subdir_tree as well, since it does not exist
            # yet
            subdir_tree = Tree()
        subdir_tree.add(_git_default_file_mode, filename, blob.id)

        # create new root tree
        tree = self.current_tree
        tree.add(stat.S_IFDIR, subdir, subdir_tree.id)

        # create commit
        commit = Commit()
        commit.parents = [self.current_commit.id]
        commit.tree = tree.id
        commit.author = commit.committer = self.wiki_user
        commit.commit_time = commit.author_time = int(time.time())
        commit.commit_timezone = commit.author_timezone = parse_timezone(
            time.timezone)[0]
        commit.encoding = 'UTF-8'
        commit.message = commit_msg.encode('utf-8')

        # store all objects
        self.repo.object_store.add_object(blob)
        self.repo.object_store.add_object(subdir_tree)
        self.repo.object_store.add_object(tree)
        self.repo.object_store.add_object(commit)

        # update the branch
        self.repo.refs[self.head] = commit.id
def step_impl_given(context):
    context.test_git_repo_dir = tempfile.mkdtemp("paasta_tools_deployments_json_itest")
    context.test_git_repo = Repo.init(context.test_git_repo_dir)
    paasta_print("Temp repo in %s" % context.test_git_repo_dir)

    blob = Blob.from_string(b"My file content\n")
    tree = Tree()
    tree.add(b"spam", 0o0100644, blob.id)

    commit = Commit()
    commit.author = commit.committer = b"itest author"
    commit.commit_time = commit.author_time = int(time())
    commit.commit_timezone = commit.author_timezone = parse_timezone(b"-0200")[0]
    commit.message = b"Initial commit"
    commit.tree = tree.id

    object_store = context.test_git_repo.object_store
    object_store.add_object(blob)
    object_store.add_object(tree)
    object_store.add_object(commit)

    context.test_git_repo.refs[b"refs/heads/master"] = commit.id
    context.expected_commit_as_bytes = commit.id
    context.expected_commit = context.expected_commit_as_bytes.decode()
示例#41
0
def inventory_to_tree_and_blobs(repo, mapping, revision_id):
    stack = []
    cur = ""
    tree = Tree()

    inv = repo.get_inventory(revision_id)

    for path, entry in inv.iter_entries():
        while stack and not path.startswith(cur):
            tree.serialize()
            sha = tree.sha().hexdigest()
            yield sha, tree
            t = (stat.S_IFDIR, splitpath(cur)[-1:][0].encode('UTF-8'), sha)
            cur, tree = stack.pop()
            tree.add(*t)

        if type(entry) == InventoryDirectory:
            stack.append((cur, tree))
            cur = path
            tree = Tree()

        if type(entry) == InventoryFile:
            #FIXME: We can make potentially make this Lazy to avoid shaing lots of stuff
            # and having all these objects in memory at once
            blob = Blob()
            _, blob._text = repo.iter_files_bytes([(entry.file_id, revision_id,
                                                    path)]).next()
            sha = blob.sha().hexdigest()
            yield sha, blob

            name = splitpath(path)[-1:][0].encode('UTF-8')
            mode = stat.S_IFREG | 0644
            if entry.executable:
                mode |= 0111
            tree.add(mode, name, sha)

    while len(stack) > 1:
        tree.serialize()
        sha = tree.sha().hexdigest()
        yield sha, tree
        t = (stat.S_IFDIR, splitpath(cur)[-1:][0].encode('UTF-8'), sha)
        cur, tree = stack.pop()
        tree.add(*t)

    tree.serialize()
    yield tree.sha().hexdigest(), tree
示例#42
0
def render_tree(tree, path):
    new_tree = Tree()

    for entry in tree.items():
        item = repo[entry.sha]
        if isinstance(item, Tree):
            new_tree.add(entry.path, entry.mode, render_tree(item, path+(entry.path,)))
        elif isinstance(item, Blob):
            if entry.path.startswith(".") or ("." not in entry.path) or entry.path.endswith(".py") or entry.path.endswith(".html") or entry.path.startswith("mnist.") or entry.path.endswith(".model"):
                continue
            if not entry.path.endswith(".rst"):
                new_tree.add(entry.path, entry.mode, entry.sha)
            else:
                name = "index.html" if entry.path == 'README.rst' else (entry.path[:-4]+".html")
                new_tree.add(name, entry.mode, render_rst(item, os.path.join(*(path +(name,)))))

    store.add_object(new_tree)
    return new_tree.id
示例#43
0
    def _merge_branches(self, base, mine, other, take_mine=False):
        def load_json(path, branch):
            try:
                blob = self.blob(path, branch)
            except (KeyError, TypeError):
                return {}
            else:
                return loads(blob.as_raw_string())

        merge_tree = Tree()
        base_tree, my_tree, other_tree = (self._get_tree(x)
                                          for x in (base, mine, other))
        ren_detector = RenameDetector(self._repo.object_store)
        conflicts = {}

        my_changes, other_changes = (tree_changes(self._repo.object_store,
                                                  base_tree.id,
                                                  x.id,
                                                  want_unchanged=True,
                                                  rename_detector=ren_detector)
                                     for x in (my_tree, other_tree))

        changes_by_path = defaultdict(list)
        for change in chain(my_changes, other_changes):
            if change.type == CHANGE_DELETE or change.type == CHANGE_RENAME:
                path = change.old.path
            else:
                path = change.new.path
            changes_by_path[path].append(change)
        had_conflict = False

        for path, changes in changes_by_path.items():
            if len(changes) == 2:
                my_changes, other_changes = changes
                if my_changes.type == CHANGE_DELETE:
                    if other_changes.type in (CHANGE_RENAME, CHANGE_MODIFY):
                        merge_tree.add(other_changes.new.path, FILE_MODE,
                                       other_changes.new.sha)
                    else:
                        continue
                elif other_changes.type == CHANGE_DELETE:
                    if my_changes.type in (CHANGE_RENAME, CHANGE_MODIFY):
                        merge_tree.add(my_changes.new.path, FILE_MODE,
                                       my_changes.new.sha)
                    else:
                        continue
                else:
                    jsons = [load_json(path, x) for x in (base, mine, other)]
                    base_json, my_json, other_json = jsons
                    # When dealing with renames, file contents are under the
                    # 'new' path. Note that the file will be finally stored
                    # under the name given by the last rename.
                    if other_changes.type == CHANGE_RENAME:
                        other_json = load_json(other_changes.new.path, other)
                        path = other_changes.new.path
                    if my_changes.type == CHANGE_RENAME:
                        my_json = load_json(my_changes.new.path, mine)
                        path = my_changes.new.path
                    if take_mine:
                        merged_json = my_json or other_json or base_json
                    else:
                        merged_json, merge_conflict = merge_jsons(*jsons)
                        if merge_conflict:
                            conflicts[path] = merged_json
                        had_conflict = had_conflict or merge_conflict
                    merged_blob = Blob.from_string(
                        dumps(merged_json, sort_keys=True, indent=4))
                    self._update_store(merged_blob)
                    merge_tree.add(path, FILE_MODE, merged_blob.id)
            else:
                data = (load_json(path, mine) or load_json(path, other)
                        or load_json(path, base))
                blob = Blob.from_string(dumps(data, sort_keys=True, indent=4))
                self._update_store(blob)
                merge_tree.add(path, FILE_MODE, blob.id)
        self._update_store(merge_tree)
        return merge_tree, conflicts
示例#44
0
 def test_tree_diff(self):
     f = BytesIO()
     store = MemoryObjectStore()
     added = Blob.from_string(b"add\n")
     removed = Blob.from_string(b"removed\n")
     changed1 = Blob.from_string(b"unchanged\nremoved\n")
     changed2 = Blob.from_string(b"unchanged\nadded\n")
     unchanged = Blob.from_string(b"unchanged\n")
     tree1 = Tree()
     tree1.add(b"removed.txt", 0o644, removed.id)
     tree1.add(b"changed.txt", 0o644, changed1.id)
     tree1.add(b"unchanged.txt", 0o644, changed1.id)
     tree2 = Tree()
     tree2.add(b"added.txt", 0o644, added.id)
     tree2.add(b"changed.txt", 0o644, changed2.id)
     tree2.add(b"unchanged.txt", 0o644, changed1.id)
     store.add_objects([(o, None) for o in [
         tree1, tree2, added, removed, changed1, changed2, unchanged]])
     write_tree_diff(f, store, tree1.id, tree2.id)
     self.assertEqual([
         b'diff --git a/added.txt b/added.txt',
         b'new file mode 644',
         b'index 0000000..76d4bb8',
         b'--- /dev/null',
         b'+++ b/added.txt',
         b'@@ -0,0 +1 @@',
         b'+add',
         b'diff --git a/changed.txt b/changed.txt',
         b'index bf84e48..1be2436 644',
         b'--- a/changed.txt',
         b'+++ b/changed.txt',
         b'@@ -1,2 +1,2 @@',
         b' unchanged',
         b'-removed',
         b'+added',
         b'diff --git a/removed.txt b/removed.txt',
         b'deleted file mode 644',
         b'index 2c3f0b3..0000000',
         b'--- a/removed.txt',
         b'+++ /dev/null',
         b'@@ -1 +0,0 @@',
         b'-removed',
         ], f.getvalue().splitlines())
示例#45
0
# abstraction of this
store = repo.object_store
print("Object store: {}".format(store))
store.add_object(blob)
print("Added one object")

# notes:
# - single object file in .git/objects now
# - "git cat-file -p <hash>": see our file!
# - file is compressed (hexdump -C .git/objects/*)

# now lets create a real "tree" object so we can give our Blob a
# filename

tree = Tree()
tree.add(b"a_file.txt", 0o100644, blob.id)
print("Tree: {}".format(tree.sha().hexdigest()))
# note: still not "in" the object repository
store.add_object(tree)

# From a user perpective, Trees live in Commit objects
commit = Commit()
commit.tree = tree
commit.author = commit.committer = b"meejah <*****@*****.**>"
commit.commit_time = commit.author_time = int(time())  # seconds since epoch
commit.commit_timezone = commit.author_timezone = -7 * (
    60 * 60)  # seconds offset; MST
commit.encoding = b"utf8"
commit.message = b"The beginning"
# no commit.parents because this is the first Commit