def test_simple(self): outstream = BytesIO() errstream = BytesIO() # create a file for initial commit handle, fullpath = tempfile.mkstemp(dir=self.repo.path) os.close(handle) filename = os.path.basename(fullpath) porcelain.add(repo=self.repo.path, paths=filename) porcelain.commit(repo=self.repo.path, message=b'test', author=b'test', committer=b'test') # Setup target repo target_path = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, target_path) target_repo = porcelain.clone(self.repo.path, target=target_path, errstream=errstream) target_repo.close() # create a second file to be pushed handle, fullpath = tempfile.mkstemp(dir=self.repo.path) os.close(handle) filename = os.path.basename(fullpath) porcelain.add(repo=self.repo.path, paths=filename) porcelain.commit(repo=self.repo.path, message=b'test2', author=b'test2', committer=b'test2') # Pull changes into the cloned repo porcelain.pull(target_path, self.repo.path, b'refs/heads/master', outstream=outstream, errstream=errstream) # Check the target repo for pushed changes with closing(Repo(target_path)) as r: self.assertEqual(r[b'HEAD'].id, self.repo[b'HEAD'].id)
def setUp(self): super(PullTests, self).setUp() # create a file for initial commit handle, fullpath = tempfile.mkstemp(dir=self.repo.path) os.close(handle) porcelain.add(repo=self.repo.path, paths=fullpath) porcelain.commit(repo=self.repo.path, message=b'test', author=b'test <email>', committer=b'test <email>') # Setup target repo self.target_path = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, self.target_path) target_repo = porcelain.clone(self.repo.path, target=self.target_path, errstream=BytesIO()) target_repo.close() # create a second file to be pushed handle, fullpath = tempfile.mkstemp(dir=self.repo.path) os.close(handle) porcelain.add(repo=self.repo.path, paths=fullpath) porcelain.commit(repo=self.repo.path, message=b'test2', author=b'test2 <email>', committer=b'test2 <email>') self.assertTrue(b'refs/heads/master' in self.repo.refs) self.assertTrue(b'refs/heads/master' in target_repo.refs)
def test_hard_commit(self): with open(os.path.join(self.repo.path, "foo"), "w") as f: f.write("BAR") porcelain.add(self.repo.path, paths=["foo"]) sha = porcelain.commit( self.repo.path, message=b"Some message", committer=b"Jane <*****@*****.**>", author=b"John <*****@*****.**>", ) with open(os.path.join(self.repo.path, "foo"), "wb") as f: f.write(b"BAZ") porcelain.add(self.repo.path, paths=["foo"]) porcelain.commit( self.repo.path, message=b"Some other message", committer=b"Jane <*****@*****.**>", author=b"John <*****@*****.**>", ) porcelain.reset(self.repo, "hard", sha) index = self.repo.open_index() changes = list(tree_changes(self.repo, index.commit(self.repo.object_store), self.repo[sha].tree)) self.assertEqual([], changes)
def test_hard_head(self): f = open(os.path.join(self.repo.path, 'foo'), 'w') try: f.write("BAR") finally: f.close() porcelain.add(self.repo.path, paths=["foo"]) porcelain.commit(self.repo.path, message="Some message", committer="Jane <*****@*****.**>", author="John <*****@*****.**>") f = open(os.path.join(self.repo.path, 'foo'), 'w') try: f.write("OOH") finally: f.close() porcelain.reset(self.repo, "hard", "HEAD") index = self.repo.open_index() changes = list(tree_changes(self.repo, index.commit(self.repo.object_store), self.repo['HEAD'].tree)) self.assertEqual([], changes)
def test_simple(self): outstream = BytesIO() errstream = BytesIO() # create a file for initial commit handle, fullpath = tempfile.mkstemp(dir=self.repo.path) os.close(handle) filename = os.path.basename(fullpath) porcelain.add(repo=self.repo.path, paths=filename) porcelain.commit(repo=self.repo.path, message=b"test", author=b"test", committer=b"test") # Setup target repo target_path = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, target_path) target_repo = porcelain.clone(self.repo.path, target=target_path, errstream=errstream) # create a second file to be pushed handle, fullpath = tempfile.mkstemp(dir=self.repo.path) os.close(handle) filename = os.path.basename(fullpath) porcelain.add(repo=self.repo.path, paths=filename) porcelain.commit(repo=self.repo.path, message=b"test2", author=b"test2", committer=b"test2") self.assertFalse(self.repo[b"HEAD"].id in target_repo) target_repo.close() # Fetch changes into the cloned repo porcelain.fetch(target_path, self.repo.path, outstream=outstream, errstream=errstream) # Check the target repo for pushed changes with closing(Repo(target_path)) as r: self.assertTrue(self.repo[b"HEAD"].id in r)
def test_delete(self): """Basic test of porcelain push, removing a branch. """ outstream = BytesIO() errstream = BytesIO() porcelain.commit(repo=self.repo.path, message=b'init', author=b'', committer=b'') # Setup target repo cloned from temp test repo clone_path = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, clone_path) target_repo = porcelain.clone(self.repo.path, target=clone_path, errstream=errstream) target_repo.close() # Setup a non-checked out branch in the remote refs_path = b"refs/heads/foo" new_id = self.repo[b'HEAD'].id self.assertNotEqual(new_id, ZERO_SHA) self.repo.refs[refs_path] = new_id # Push to the remote porcelain.push(clone_path, self.repo.path, b":" + refs_path, outstream=outstream, errstream=errstream) self.assertEqual({ b'HEAD': new_id, b'refs/heads/master': new_id, }, self.repo.get_refs())
def rename_file(self, old_path, new_path): # paths must not be unicode. :( old_files = [old_path] new_files = [new_path] if self.save_script and ".ipynb" in old_path: old_files.append(old_files[0].replace('.ipynb', '.py')) new_files.append(new_files[0].replace('.ipynb', '.py')) renamed = super(GitNotebookManager, self).rename_file(old_path, new_path) isFolder = os.path.splitext(old_path)[-1] == "" if any(old_path.endswith(ext) for ext in self._tracked_ext) or isFolder: if isFolder: subprocess.call(["git", "rm", "-r", str(old_path)], shell=False) subprocess.call(["git", "add", str(new_path)], shell=False) self._repo = None self._check_repo() else: git.rm(self._repo, [str(_) for _ in old_files]) git.add(self._repo, [str(_) for _ in new_files]) self.log.debug("Notebook renamed from '%s' to '%s'" % (old_files[0], new_files[0])) git.commit(self._repo, "IPython notebook rename\n\n" "Automated commit from IPython via ipylogue", committer=self.committer_fullname) # git.push(self._repo, self._repo.get_config()[('remote', 'origin')]["url"], "refs/heads/master") return renamed
def test_simple(self): outstream = BytesIO() errstream = BytesIO() # create a file for initial commit handle, fullpath = tempfile.mkstemp(dir=self.repo.path) os.close(handle) filename = os.path.basename(fullpath) porcelain.add(repo=self.repo.path, paths=filename) porcelain.commit(repo=self.repo.path, message=b'test', author=b'test', committer=b'test') # Setup target repo target_path = tempfile.mkdtemp() target_repo = porcelain.clone(self.repo.path, target=target_path, errstream=errstream) # create a second file to be pushed handle, fullpath = tempfile.mkstemp(dir=self.repo.path) os.close(handle) filename = os.path.basename(fullpath) porcelain.add(repo=self.repo.path, paths=filename) porcelain.commit(repo=self.repo.path, message=b'test2', author=b'test2', committer=b'test2') self.assertFalse(self.repo[b'HEAD'].id in target_repo) # Fetch changes into the cloned repo porcelain.fetch(target_path, self.repo.path, outstream=outstream, errstream=errstream) # Check the target repo for pushed changes r = Repo(target_path) self.assertTrue(self.repo[b'HEAD'].id in r)
def test_simple(self): outstream = BytesIO() errstream = BytesIO() # create a file for initial commit handle, fullpath = tempfile.mkstemp(dir=self.repo.path) filename = os.path.basename(fullpath) porcelain.add(repo=self.repo.path, paths=filename) porcelain.commit(repo=self.repo.path, message='test', author='test', committer='test') # Setup target repo target_path = tempfile.mkdtemp() porcelain.clone(self.repo.path, target=target_path, outstream=outstream) # create a second file to be pushed handle, fullpath = tempfile.mkstemp(dir=self.repo.path) filename = os.path.basename(fullpath) porcelain.add(repo=self.repo.path, paths=filename) porcelain.commit(repo=self.repo.path, message='test2', author='test2', committer='test2') # Pull changes into the cloned repo porcelain.pull(target_path, self.repo.path, 'refs/heads/master', outstream=outstream, errstream=errstream) # Check the target repo for pushed changes r = Repo(target_path) self.assertEqual(r['HEAD'].id, self.repo['HEAD'].id)
def test_empty(self): porcelain.commit(repo=self.repo.path, message=b'test status', author=b'', committer=b'') f = StringIO() porcelain.ls_tree(self.repo, b"HEAD", outstream=f) self.assertEqual(f.getvalue(), "")
def test_status(self): """Integration test for `status` functionality.""" # Commit a dummy file then modify it fullpath = os.path.join(self.repo.path, 'foo') with open(fullpath, 'w') as f: f.write('origstuff') porcelain.add(repo=self.repo.path, paths=['foo']) porcelain.commit(repo=self.repo.path, message=b'test status', author=b'', committer=b'') # modify access and modify time of path os.utime(fullpath, (0, 0)) with open(fullpath, 'wb') as f: f.write(b'stuff') # Make a dummy file and stage it filename_add = 'bar' fullpath = os.path.join(self.repo.path, filename_add) with open(fullpath, 'w') as f: f.write('stuff') porcelain.add(repo=self.repo.path, paths=filename_add) results = porcelain.status(self.repo) self.assertEqual(results.staged['add'][0], filename_add.encode('ascii')) self.assertEqual(results.unstaged, [b'foo'])
def test_add_default_paths(self): # create a file for initial commit fullpath = os.path.join(self.repo.path, 'blah') with open(fullpath, 'w') as f: f.write("\n") porcelain.add(repo=self.repo.path, paths=[fullpath]) porcelain.commit(repo=self.repo.path, message=b'test', author=b'test <email>', committer=b'test <email>') # Add a second test file and a file in a directory with open(os.path.join(self.repo.path, 'foo'), 'w') as f: f.write("\n") os.mkdir(os.path.join(self.repo.path, 'adir')) with open(os.path.join(self.repo.path, 'adir', 'afile'), 'w') as f: f.write("\n") cwd = os.getcwd() try: os.chdir(self.repo.path) porcelain.add(self.repo.path) finally: os.chdir(cwd) # Check that foo was added and nothing in .git was modified index = self.repo.open_index() self.assertEqual(sorted(index), [b'adir/afile', b'blah', b'foo'])
def test_status(self): """Integration test for `status` functionality.""" # Commit a dummy file then modify it fullpath = os.path.join(self.repo.path, "foo") with open(fullpath, "w") as f: f.write("origstuff") porcelain.add(repo=self.repo.path, paths=["foo"]) porcelain.commit(repo=self.repo.path, message=b"test status", author=b"", committer=b"") # modify access and modify time of path os.utime(fullpath, (0, 0)) with open(fullpath, "wb") as f: f.write(b"stuff") # Make a dummy file and stage it filename_add = "bar" fullpath = os.path.join(self.repo.path, filename_add) with open(fullpath, "w") as f: f.write("stuff") porcelain.add(repo=self.repo.path, paths=filename_add) results = porcelain.status(self.repo) self.assertEqual(results.staged["add"][0], filename_add.encode("ascii")) self.assertEqual(results.unstaged, [b"foo"])
def test_simple(self): """ Basic test of porcelain push where self.repo is the remote. First clone the remote, commit a file to the clone, then push the changes back to the remote. """ outstream = BytesIO() errstream = BytesIO() porcelain.commit(repo=self.repo.path, message=b'init', author=b'author <email>', committer=b'committer <email>') # Setup target repo cloned from temp test repo clone_path = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, clone_path) target_repo = porcelain.clone(self.repo.path, target=clone_path, errstream=errstream) try: self.assertEqual(target_repo[b'HEAD'], self.repo[b'HEAD']) finally: target_repo.close() # create a second file to be pushed back to origin handle, fullpath = tempfile.mkstemp(dir=clone_path) os.close(handle) porcelain.add(repo=clone_path, paths=[fullpath]) porcelain.commit(repo=clone_path, message=b'push', author=b'author <email>', committer=b'committer <email>') # Setup a non-checked out branch in the remote refs_path = b"refs/heads/foo" new_id = self.repo[b'HEAD'].id self.assertNotEqual(new_id, ZERO_SHA) self.repo.refs[refs_path] = new_id # Push to the remote porcelain.push(clone_path, self.repo.path, b"HEAD:" + refs_path, outstream=outstream, errstream=errstream) # Check that the target and source with Repo(clone_path) as r_clone: self.assertEqual({ b'HEAD': new_id, b'refs/heads/foo': r_clone[b'HEAD'].id, b'refs/heads/master': new_id, }, self.repo.get_refs()) self.assertEqual(r_clone[b'HEAD'].id, self.repo[refs_path].id) # Get the change in the target repo corresponding to the add # this will be in the foo branch. change = list(tree_changes(self.repo, self.repo[b'HEAD'].tree, self.repo[b'refs/heads/foo'].tree))[0] self.assertEqual(os.path.basename(fullpath), change.new.path.decode('ascii'))
def git_commit(args): if len(args) == 3: try: repo = _get_repo() #print repo.commit(name=args[1],email=args[2],message=args[0]) author = "{0} <{1}>".format(args[1], args[2]) print porcelain.commit(repo.repo, args[0], author, author ) except: print 'Error: {0}'.format(sys.exc_value) else: print command_help['commit']
def test_simple(self): # Commit a dummy file then modify it fullpath = os.path.join(self.repo.path, "foo") with open(fullpath, "w") as f: f.write("origstuff") porcelain.add(repo=self.repo.path, paths=["foo"]) porcelain.commit(repo=self.repo.path, message=b"test status", author=b"", committer=b"") f = StringIO() porcelain.ls_tree(self.repo, b"HEAD", outstream=f) self.assertEqual(f.getvalue(), "100644 blob 8b82634d7eae019850bb883f06abf428c58bc9aa\tfoo\n")
def commit(self,sender): if list(itertools.chain(*porcelain.status(self.g.path).staged.itervalues())): self.g=self._get_repo() user=self.view['user'].text email=self.view['email'].text message=self.view['message'].text author = "{0} <{1}>".format(user, email) porcelain.commit(self.g.path,message,author,author) console.hud_alert('committed') self.view['message'].text='' self.refresh() else: console.hud_alert('nothing to commit!',icon='error')
def delete(self, path): super(GitNotebookManager, self).delete(path) isFolder = os.path.splitext(path)[-1] == "" if any(path.endswith(ext) for ext in self._tracked_ext) or isFolder: if isFolder: subprocess.call(["git", "rm", "-r", str(path)[1:]], shell=False) self._repo = None self._check_repo() else: git.rm(self._repo, [str(path)[1:]]) self.log.debug("Notebook {0} deleted".format(path)) git.commit(self._repo, "IPython notebook delete\n\n" "Automated commit from IPython via ipylogue", committer=self.committer_fullname)
def test_simple(self): # Commit a dummy file then modify it fullpath = os.path.join(self.repo.path, 'foo') with open(fullpath, 'w') as f: f.write('origstuff') porcelain.add(repo=self.repo.path, paths=['foo']) porcelain.commit(repo=self.repo.path, message=b'test status', author=b'', committer=b'') f = StringIO() porcelain.ls_tree(self.repo, b"HEAD", outstream=f) self.assertEqual( f.getvalue(), '100644 blob 8b82634d7eae019850bb883f06abf428c58bc9aa\tfoo\n')
def test_simple(self): """ Basic test of porcelain push where self.repo is the remote. First clone the remote, commit a file to the clone, then push the changes back to the remote. """ outstream = BytesIO() errstream = BytesIO() porcelain.commit(repo=self.repo.path, message='init', author='', committer='') # Setup target repo cloned from temp test repo clone_path = tempfile.mkdtemp() porcelain.clone(self.repo.path, target=clone_path, outstream=outstream) # create a second file to be pushed back to origin handle, fullpath = tempfile.mkstemp(dir=clone_path) porcelain.add(repo=clone_path, paths=[os.path.basename(fullpath)]) porcelain.commit(repo=clone_path, message='push', author='', committer='') # Setup a non-checked out branch in the remote refs_path = os.path.join('refs', 'heads', 'foo') self.repo[refs_path] = self.repo['HEAD'] # Push to the remote porcelain.push(clone_path, self.repo.path, refs_path, outstream=outstream, errstream=errstream) # Check that the target and source r_clone = Repo(clone_path) # Get the change in the target repo corresponding to the add # this will be in the foo branch. change = list( tree_changes(self.repo, self.repo['HEAD'].tree, self.repo['refs/heads/foo'].tree))[0] self.assertEqual(r_clone['HEAD'].id, self.repo[refs_path].id) self.assertEqual(os.path.basename(fullpath), change.new.path)
def _rename(self, name=None, new_name=None): if not name: self.q.put([Action.ask_input, _("Rename which password?"), "", "rename"]) elif not new_name: self.q.put([Action.ask_input, _("What should the new name of {} be?").format(name), name, "rename {}".format(name)]) else: old_file_path = os.path.join(self._get_data_location(), "{}.gpg".format(name)) new_file_path = os.path.join(self._get_data_location(), "{}.gpg".format(new_name)) os.rename(old_file_path, new_file_path) if self.git_repo: porcelain.add(self.git_repo, [old_file_path, new_file_path]) porcelain.commit(self.git_repo, message="Renamed {} to {} with Pext".format(name, new_name)) self._git_push() self.q.put([Action.set_selection, []])
def commit_and_push(version: str) -> None: """ Commit and push all changes. """ repo = Repo('.') paths = ['dcosdocker.rb', 'CHANGELOG.rst', 'vagrant/Vagrantfile'] _, ignored = add(paths=paths) assert not ignored message = b'Update for release ' + version.encode('utf-8') commit(message=message) branch_name = 'master' push( repo=repo, remote_location='[email protected]:mesosphere/dcos-e2e.git', refspecs=branch_name.encode('utf-8'), )
def test_get_tree_changes_delete(self): """Unit test for get_tree_changes delete.""" # Make a dummy file, stage, commit, remove filename = "foo" with open(os.path.join(self.repo.path, filename), "w") as f: f.write("stuff") porcelain.add(repo=self.repo.path, paths=filename) porcelain.commit(repo=self.repo.path, message=b"test status", author=b"", committer=b"") porcelain.rm(repo=self.repo.path, paths=[filename]) changes = porcelain.get_tree_changes(self.repo.path) self.assertEqual(changes["delete"][0], filename.encode("ascii")) self.assertEqual(len(changes["add"]), 0) self.assertEqual(len(changes["modify"]), 0) self.assertEqual(len(changes["delete"]), 1)
def delete(self, request, user, data, message=None): '''Delete file(s) from repository ''' files_to_del = data.get('files') if not files_to_del: raise DataError('Nothing to delete') # convert to list if not already if not isinstance(files_to_del, (list, tuple)): files_to_del = [files_to_del] filenames = [] path = self.path for file in files_to_del: filepath = os.path.join(path, self._format_filename(file)) # remove only files that really exist and not dirs if os.path.exists(filepath) and os.path.isfile(filepath): # remove from disk os.remove(filepath) filename = get_rel_dir(filepath, self.repo.path) filenames.append(filename) if filenames: rm(self.repo, filenames) if not message: message = 'Deleted %s' % ';'.join(filenames) return commit(self.repo, _b(message), committer=_b(user.username))
def commit_and_push(version: str, repository: Repository) -> None: """ Commit and push all changes. """ local_repository = Repo('.') paths = ['CHANGELOG.rst'] _, ignored = add(paths=paths) assert not ignored message = b'Update for release ' + version.encode('utf-8') commit(message=message) branch_name = 'master' push( repo=local_repository, remote_location=repository.ssh_url, refspecs=branch_name.encode('utf-8'), )
def test_remove_file(self): fullpath = os.path.join(self.repo.path, 'foo') with open(fullpath, 'w') as f: f.write("BAR") porcelain.add(self.repo.path, paths=[fullpath]) porcelain.commit(repo=self.repo, message=b'test', author=b'test <email>', committer=b'test <email>') self.assertTrue(os.path.exists(os.path.join(self.repo.path, 'foo'))) cwd = os.getcwd() try: os.chdir(self.repo.path) porcelain.remove(self.repo.path, paths=["foo"]) finally: os.chdir(cwd) self.assertFalse(os.path.exists(os.path.join(self.repo.path, 'foo')))
def test_simple(self): # Commit a dummy file then modify it fullpath = os.path.join(self.repo.path, 'foo') with open(fullpath, 'w') as f: f.write('origstuff') porcelain.add(repo=self.repo.path, paths=[fullpath]) porcelain.commit(repo=self.repo.path, message=b'test status', author=b'author <email>', committer=b'committer <email>') f = StringIO() porcelain.ls_tree(self.repo, b"HEAD", outstream=f) self.assertEqual( f.getvalue(), '100644 blob 8b82634d7eae019850bb883f06abf428c58bc9aa\tfoo\n')
def git_reset_repo_to_origin(): try: repo = porcelain.Repo(database) porcelain.fetch(repo) tree_head_id = repo[repo[b'refs/heads/master'].tree].id tree_origin_master_id = repo[ repo[b'refs/remotes/origin/master'].tree].id store = repo.object_store list_all_files_head = list_all_files(store, tree_head_id) list_all_files_origin_master = list_all_files(store, tree_origin_master_id) deleted_files = list( set(list_all_files_head) - set(list_all_files_origin_master)) # print(deleted_files) if deleted_files != []: for all in deleted_files: file_path = os.path.join(database, all.decode('utf-8')) os.remove(file_path) status = porcelain.status(repo) repo.stage(status.unstaged) porcelain.commit(repo, message="delete files") ###working### porcelain.reset(repo, "hard", treeish=b"refs/remotes/origin/master") porcelain.clean(repo=repo, target_dir=database) resolve_divergence() ######## return True except MaxRetryError: print('MaxRetryError') return False except ProtocolError: print('ProtocolError') return False
def _remove(self, name=None, confirmed=None): if not name: self.q.put([Action.ask_input, _("Remove which password?"), "", "remove"]) elif confirmed is None: self.q.put([Action.ask_question, _("Are you sure you want to remove {}?").format(name), "remove {}".format(name)]) elif not confirmed: return else: file_path = os.path.join(self._get_data_location(), "{}.gpg".format(name)) os.remove(file_path) if self.git_repo: porcelain.add(self.git_repo, [file_path]) porcelain.commit(self.git_repo, message="Removed {} with Pext".format(name)) self._git_push() self.q.put([Action.set_selection, []])
def test_some(self): cid = porcelain.commit(repo=self.repo.path, message=b'test status', author=b'', committer=b'') self.assertEqual({ b'refs/heads/master': cid, b'HEAD': cid}, porcelain.ls_remote(self.repo.path))
def upload(self, cmd: str, meta: dict): index = os.path.join(self.cached_repo, INDEX_FILE) if os.path.exists(index): os.remove(index) self._log.info("Writing the new index.json ...") with open(index, "w") as _out: json.dump(self.contents, _out) # implementation of git add --all is pretty bad, changing directory is the easiest way os.chdir(self.cached_repo) git.add() git.commit(message=self.COMMIT_MESSAGES[cmd].format(**meta)) self._log.info("Pushing the updated index ...") # TODO: change when https://github.com/dulwich/dulwich/issues/631 gets addressed git.push(self.cached_repo, self.remote_url, b"master") if self._are_local_and_remote_heads_different(): self._log.error("Push has failed") raise ValueError
def test_with_remote_name(self): remote_name = b'origin' outstream = BytesIO() errstream = BytesIO() # create a file for initial commit handle, fullpath = tempfile.mkstemp(dir=self.repo.path) os.close(handle) porcelain.add(repo=self.repo.path, paths=fullpath) porcelain.commit(repo=self.repo.path, message=b'test', author=b'test <email>', committer=b'test <email>') # Setup target repo target_path = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, target_path) target_repo = porcelain.clone(self.repo.path, target=target_path, errstream=errstream) # Capture current refs target_refs = target_repo.get_refs() # create a second file to be pushed handle, fullpath = tempfile.mkstemp(dir=self.repo.path) os.close(handle) porcelain.add(repo=self.repo.path, paths=fullpath) porcelain.commit(repo=self.repo.path, message=b'test2', author=b'test2 <email>', committer=b'test2 <email>') self.assertFalse(self.repo[b'HEAD'].id in target_repo) target_repo.close() # Fetch changes into the cloned repo porcelain.fetch(target_path, self.repo.path, remote_name=remote_name, outstream=outstream, errstream=errstream) # Assert that fetch updated the local image of the remote self.assert_correct_remote_refs( target_repo.get_refs(), self.repo.get_refs()) # Check the target repo for pushed changes, as well as updates # for the refs with Repo(target_path) as r: self.assertTrue(self.repo[b'HEAD'].id in r) self.assertNotEqual(self.repo.get_refs(), target_refs)
def test_custom_author(self): c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1], [3, 1, 2]]) self.repo.refs[b"refs/heads/foo"] = c3.id sha = porcelain.commit(self.repo.path, message=b"Some message", author=b"Joe <*****@*****.**>", committer=b"Bob <*****@*****.**>") self.assertTrue(isinstance(sha, bytes)) self.assertEqual(len(sha), 40)
def test_get_tree_changes_delete(self): """Unit test for get_tree_changes delete.""" # Make a dummy file, stage, commit, remove filename = 'foo' with open(os.path.join(self.repo.path, filename), 'w') as f: f.write('stuff') porcelain.add(repo=self.repo.path, paths=filename) porcelain.commit(repo=self.repo.path, message=b'test status', author=b'', committer=b'') porcelain.rm(repo=self.repo.path, paths=[filename]) changes = porcelain.get_tree_changes(self.repo.path) self.assertEqual(changes['delete'][0], filename.encode('ascii')) self.assertEqual(len(changes['add']), 0) self.assertEqual(len(changes['modify']), 0) self.assertEqual(len(changes['delete']), 1)
def test_simple(self): outstream = BytesIO() errstream = BytesIO() # create a file for initial commit handle, fullpath = tempfile.mkstemp(dir=self.repo.path) os.close(handle) filename = os.path.basename(fullpath) porcelain.add(repo=self.repo.path, paths=filename) porcelain.commit(repo=self.repo.path, message=b'test', author=b'test', committer=b'test') # Setup target repo target_path = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, target_path) target_repo = porcelain.clone(self.repo.path, target=target_path, errstream=errstream) target_repo.close() # create a second file to be pushed handle, fullpath = tempfile.mkstemp(dir=self.repo.path) os.close(handle) filename = os.path.basename(fullpath) porcelain.add(repo=self.repo.path, paths=filename) porcelain.commit(repo=self.repo.path, message=b'test2', author=b'test2', committer=b'test2') self.assertTrue(b'refs/heads/master' in self.repo.refs) self.assertTrue(b'refs/heads/master' in target_repo.refs) # Pull changes into the cloned repo porcelain.pull(target_path, self.repo.path, b'refs/heads/master', outstream=outstream, errstream=errstream) # Check the target repo for pushed changes with closing(Repo(target_path)) as r: self.assertEqual(r[b'HEAD'].id, self.repo[b'HEAD'].id)
def push(self): QApplication.setOverrideCursor(Qt.WaitCursor) username = self.username.text() userid = self.userid.text() password = self.password.text() reponame = self.reponame.text() settings = QSettings(QSettings.IniFormat, QSettings.UserScope, QCoreApplication.organizationName(), QCoreApplication.applicationName()) settings.setValue("github.userid", userid) settings.setValue("github.username", username) settings.setValue("github.reponame", reponame) os.chdir(self.site_path) gitpath = os.path.join(self.site_path, ".git") if os.path.exists(gitpath): repo = porcelain.open_repo(self.site_path) else: repo = porcelain.init(self.site_path) for r, dirs, files in os.walk(self.site_path): for f in files: p = os.path.join(r, f)[len(self.site_path) + 1:] if not ".git" in p: porcelain.add(repo, p) self.html = "<p>adding: " + p + "</p>" + self.html self.browser.setHtml(self.html) QCoreApplication.processEvents() self.html = "<p>Commiting changes</p>" + self.html self.browser.setHtml(self.html) QCoreApplication.processEvents() porcelain.commit(repo, b"A sample commit") self.html = "<p>Pushing to server</p>" + self.html self.browser.setHtml(self.html) QCoreApplication.processEvents() porcelain.push( self.site_path, "https://" + userid + ":" + password + "@github.com/" + username + "/" + reponame + ".git", "master") self.html = "<p>Ready</p>" + self.html self.browser.setHtml(self.html) QCoreApplication.processEvents() QApplication.restoreOverrideCursor()
def test_add_default_paths_subdir(self): os.mkdir(os.path.join(self.repo.path, 'foo')) with open(os.path.join(self.repo.path, 'blah'), 'w') as f: f.write("\n") with open(os.path.join(self.repo.path, 'foo', 'blie'), 'w') as f: f.write("\n") cwd = os.getcwd() try: os.chdir(os.path.join(self.repo.path, 'foo')) porcelain.add(repo=self.repo.path) porcelain.commit(repo=self.repo.path, message=b'test', author=b'test', committer=b'test') finally: os.chdir(cwd) index = self.repo.open_index() self.assertEqual(sorted(index), [b'foo/blie'])
def test_simple(self): """ Basic test of porcelain push where self.repo is the remote. First clone the remote, commit a file to the clone, then push the changes back to the remote. """ outstream = BytesIO() errstream = BytesIO() porcelain.commit(repo=self.repo.path, message=b'init', author=b'', committer=b'') # Setup target repo cloned from temp test repo clone_path = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, clone_path) target_repo = porcelain.clone(self.repo.path, target=clone_path, errstream=errstream) target_repo.close() # create a second file to be pushed back to origin handle, fullpath = tempfile.mkstemp(dir=clone_path) os.close(handle) porcelain.add(repo=clone_path, paths=[os.path.basename(fullpath)]) porcelain.commit(repo=clone_path, message=b'push', author=b'', committer=b'') # Setup a non-checked out branch in the remote refs_path = b"refs/heads/foo" self.repo.refs[refs_path] = self.repo[b'HEAD'].id # Push to the remote porcelain.push(clone_path, self.repo.path, b"HEAD:" + refs_path, outstream=outstream, errstream=errstream) # Check that the target and source with closing(Repo(clone_path)) as r_clone: self.assertEqual(r_clone[b'HEAD'].id, self.repo[refs_path].id) # Get the change in the target repo corresponding to the add # this will be in the foo branch. change = list(tree_changes(self.repo, self.repo[b'HEAD'].tree, self.repo[b'refs/heads/foo'].tree))[0] self.assertEqual(os.path.basename(fullpath), change.new.path.decode('ascii'))
def save(self): primer_dir = pathlib.Path(self.confdir) primer_project_dir = primer_dir / 'projects' project_dir = pathlib.Path(self.name) project = self.name if self.base: project_dir = self.base / project_dir if project_dir.exists(): raise exceptions.ProjectFolderExistsError(self.name) if not primer_project_dir.exists(): primer_project_dir.mkdir(parents=True, exist_ok=True) repo = porcelain.init(str(primer_dir)) else: repo = Repo(str(primer_dir)) projects_yml = primer_dir / 'projects.yml' if projects_yml.exists(): with projects_yml.open('r') as yml_file: projects_def = yaml.load(yml_file, Loader=Loader) projects = projects_def['primer']['projects'] if project in projects: raise exceptions.ProjectExistsError(self.name) projects.append(project) else: projects_def = OrderedDict() projects_def['version'] = 1 projects_def['primer'] = {'projects': [self.name]} with projects_yml.open('w') as yml_file: yaml.dump(projects_def, yml_file, default_flow_style=False, Dumper=Dumper) project_dir.mkdir(parents=True, exist_ok=True) header = OrderedDict() header['version'] = 1 header['primer'] = {'repositories': {}, 'directory': str(project_dir)} primer_yml = primer_project_dir / '{}.yml'.format(self.name) with primer_yml.open('w') as yml_file: yaml.dump(header, yml_file, default_flow_style=False, Dumper=Dumper) porcelain.add(repo, primer_yml) porcelain.commit(repo, message="added {}".format(self.name))
def test_add_default_paths_subdir(self): os.mkdir(os.path.join(self.repo.path, 'foo')) with open(os.path.join(self.repo.path, 'blah'), 'w') as f: f.write("\n") with open(os.path.join(self.repo.path, 'foo', 'blie'), 'w') as f: f.write("\n") cwd = os.getcwd() try: os.chdir(os.path.join(self.repo.path, 'foo')) porcelain.add(repo=self.repo.path) porcelain.commit(repo=self.repo.path, message=b'test', author=b'test <email>', committer=b'test <email>') finally: os.chdir(cwd) index = self.repo.open_index() self.assertEqual(sorted(index), [b'foo/blie'])
def test_add_default_paths(self): # create a file for initial commit with open(os.path.join(self.repo.path, "blah"), "w") as f: f.write("\n") porcelain.add(repo=self.repo.path, paths=["blah"]) porcelain.commit(repo=self.repo.path, message=b"test", author=b"test", committer=b"test") # Add a second test file and a file in a directory with open(os.path.join(self.repo.path, "foo"), "w") as f: f.write("\n") os.mkdir(os.path.join(self.repo.path, "adir")) with open(os.path.join(self.repo.path, "adir", "afile"), "w") as f: f.write("\n") porcelain.add(self.repo.path) # Check that foo was added and nothing in .git was modified index = self.repo.open_index() self.assertEqual(sorted(index), [b"adir/afile", b"blah", b"foo"])
def save(self, model, path=''): self.notebook_dir = super(GitNotebookManager, self)._get_os_path("") self._check_repo() model = super(GitNotebookManager, self).save(model, path) os_path = super(GitNotebookManager, self)._get_os_path(model['path']) local_path = os_path[len(self.notebook_dir):].strip('/') git.add(self._repo, [str(local_path)]) # path must not be unicode. :( if self.save_script: git.add(self._repo, [str(os.path.splitext(local_path)[0] + '.py')]) self.log.debug("Notebook added %s" % local_path) git.commit(self._repo, "IPython notebook save\n\n" "Automated commit from IPython via ipylogue", committer=self.committer_fullname) return model
def dbBlock(args, api=False, toggle=True): # Retrieve user record db = TinyDB(args.userdb, **db_format) User = Query() if api: table = db.table('api_users') else: table = db if toggle: verb = ('Block', 'Blocking', 'blocked') else: verb = ('Unblock', 'Unblocking', 'unblocked') user_list = table.search(User.userid == args.userid) status = len(user_list) if status < 1: print('User {} not found. Exiting.'.format(args.userid)) sys.exit(1) elif status > 1: print('ID not unique. Is there a problem in the database?') sys.exit(2) print('{} user {}...'.format(verb[1], args.userid)) user = user_list[0] # Update user record table.update({'blocked': toggle}, doc_ids=[user.doc_id]) # Add file to Git index try: repo = Repo(os.path.dirname(args.userdb)) except NotGitRepository: repo = Repo.init(os.path.dirname(args.userdb)) git.add(repo=repo, paths=[args.userdb]) # Prepare commit information committer = 'MSCWG <{}>'.format(mscwg_email).encode('utf8') author = committer message = ('{} user {}\n\nChanged by dbctl.py'.format( verb[0], args.userid).encode('utf8')) # Execute commit git.commit(repo, message=message, author=author, committer=committer) print('\nUser successfully {}'.format(verb[2]))
def test_hard_head(self): with open(os.path.join(self.repo.path, 'foo'), 'w') as f: f.write("BAR") porcelain.add(self.repo.path, paths=["foo"]) porcelain.commit(self.repo.path, message=b"Some message", committer=b"Jane <*****@*****.**>", author=b"John <*****@*****.**>") with open(os.path.join(self.repo.path, 'foo'), 'wb') as f: f.write(b"OOH") porcelain.reset(self.repo, "hard", b"HEAD") index = self.repo.open_index() changes = list(tree_changes(self.repo, index.commit(self.repo.object_store), self.repo[b'HEAD'].tree)) self.assertEqual([], changes)
def _append_password(self, name, value): current_data = self.password_store.get_decrypted_password(name) if not current_data.endswith('\n'): current_data = "{}\n".format(current_data) if not value.endswith('\n'): value = "{}\n".format(value) self.password_store.insert_password(name, "{}{}".format(current_data, value)) if self.git_repo: porcelain.add( self.git_repo, os.path.join(self._get_data_location(), "{}.gpg".format(name))) porcelain.commit(self.git_repo, message="Appended to {} with Pext".format(name)) self._git_push()
def test_simple(self): """ Basic test of porcelain push where self.repo is the remote. First clone the remote, commit a file to the clone, then push the changes back to the remote. """ outstream = BytesIO() errstream = BytesIO() porcelain.commit(repo=self.repo.path, message=b'init', author=b'', committer=b'') # Setup target repo cloned from temp test repo clone_path = tempfile.mkdtemp() target_repo = porcelain.clone(self.repo.path, target=clone_path, errstream=errstream) target_repo.close() # create a second file to be pushed back to origin handle, fullpath = tempfile.mkstemp(dir=clone_path) os.close(handle) porcelain.add(repo=clone_path, paths=[os.path.basename(fullpath)]) porcelain.commit(repo=clone_path, message=b'push', author=b'', committer=b'') # Setup a non-checked out branch in the remote refs_path = b"refs/heads/foo" self.repo[refs_path] = self.repo[b'HEAD'] # Push to the remote porcelain.push(clone_path, self.repo.path, refs_path, outstream=outstream, errstream=errstream) # Check that the target and source with closing(Repo(clone_path)) as r_clone: # Get the change in the target repo corresponding to the add # this will be in the foo branch. change = list(tree_changes(self.repo, self.repo[b'HEAD'].tree, self.repo[b'refs/heads/foo'].tree))[0] self.assertEqual(r_clone[b'HEAD'].id, self.repo[refs_path].id) self.assertEqual(os.path.basename(fullpath), change.new.path.decode('ascii'))
def _copy(self, name=None, copy_name=None): if not name: self.q.put([Action.ask_input, _("Copy which password?"), "", "copy"]) elif not copy_name: self.q.put([Action.ask_input, _("What should the copy of {} be named?").format(name), name, "copy {}".format(name)]) else: try: original_file_path = os.path.join(self._get_data_location(), "{}.gpg".format(name)) copy_file_path = os.path.join(self._get_data_location(), "{}.gpg".format(copy_name)) shutil.copyfile(original_file_path, copy_file_path) if self.git_repo: porcelain.add(self.git_repo, [copy_file_path]) porcelain.commit(self.git_repo, message="Copied {} to {} with Pext".format(name, copy_name)) self._git_push() except shutil.SameFileError: self.q.put([Action.ask_input, _("What should the copy of {} be named?").format(name), name, "copy {}".format(name)]) return self.q.put([Action.set_selection, []])
def test_add_default_paths(self): # create a file for initial commit with open(os.path.join(self.repo.path, 'blah'), 'w') as f: f.write("\n") porcelain.add(repo=self.repo.path, paths=['blah']) porcelain.commit(repo=self.repo.path, message=b'test', author=b'test', committer=b'test') # Add a second test file and a file in a directory with open(os.path.join(self.repo.path, 'foo'), 'w') as f: f.write("\n") os.mkdir(os.path.join(self.repo.path, 'adir')) with open(os.path.join(self.repo.path, 'adir', 'afile'), 'w') as f: f.write("\n") porcelain.add(self.repo.path) # Check that foo was added and nothing in .git was modified index = self.repo.open_index() self.assertEqual(sorted(index), [b'adir/afile', b'blah', b'foo'])
def test_get_tree_changes_modify(self): """Unit test for get_tree_changes modify.""" # Make a dummy file, stage, commit, modify filename = 'foo' fullpath = os.path.join(self.repo.path, filename) with open(fullpath, 'w') as f: f.write('stuff') porcelain.add(repo=self.repo.path, paths=filename) porcelain.commit(repo=self.repo.path, message='test status', author='', committer='') with open(fullpath, 'w') as f: f.write('otherstuff') porcelain.add(repo=self.repo.path, paths=filename) changes = porcelain.get_tree_changes(self.repo.path) self.assertEqual(changes['modify'][0], filename) self.assertEqual(len(changes['add']), 0) self.assertEqual(len(changes['modify']), 1) self.assertEqual(len(changes['delete']), 0)
def test_simple(self): outstream = BytesIO() errstream = BytesIO() # create a file for initial commit handle, fullpath = tempfile.mkstemp(dir=self.repo.path) os.close(handle) porcelain.add(repo=self.repo.path, paths=fullpath) porcelain.commit(repo=self.repo.path, message=b'test', author=b'test <email>', committer=b'test <email>') # Setup target repo target_path = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, target_path) target_repo = porcelain.clone(self.repo.path, target=target_path, errstream=errstream) # create a second file to be pushed handle, fullpath = tempfile.mkstemp(dir=self.repo.path) os.close(handle) porcelain.add(repo=self.repo.path, paths=fullpath) porcelain.commit(repo=self.repo.path, message=b'test2', author=b'test2 <email>', committer=b'test2 <email>') self.assertFalse(self.repo[b'HEAD'].id in target_repo) target_repo.close() # Fetch changes into the cloned repo porcelain.fetch(target_path, self.repo.path, outstream=outstream, errstream=errstream) # Check the target repo for pushed changes with Repo(target_path) as r: self.assertTrue(self.repo[b'HEAD'].id in r)
def update(repo_url, logger=None): if logger: logger.info("Updating docs for: %s", repo_url) else: print("Updating docs for: %s" % repo_url) try: shutil.rmtree(package_folder_name) except: pass repo = porcelain.clone(package_git_url, package_folder_name) refspecs = b"HEAD:refs/heads/%s" %package_git_branch porcelain.pull(repo, package_git_url, refspecs = refspecs) repo_url = repo_url.split("\n")[0] repo_name = repo_url.split('/')[-1] readme_md, readme_name = loadReadme(repo_url) readme_md, readme_title = addTitleToReadme(readme_md, repo_url) readme_md = addEditLink(readme_md, readme_name, repo_url) updateMenu(readme_md, repo_name, repo) updateReadmePage(readme_md, repo_name, repo) updateLandingPage(readme_title, repo) staged = porcelain.status(repo).staged if (len(staged['add']) == 0) and (len(staged['modify']) == 0): if logger: logger.info("No changes to commit") else: print("No changes to commit") else: if logger: logger.info("Commiting changes for %s", repo_name) else: print("Commiting changes for %s" % repo_name) porcelain.commit(repo, b"Updated docs for %s" % repo_name) porcelain.push(repo, package_git_url, refspecs = refspecs) try: shutil.rmtree(package_folder_name) except Exception, err: if logger: logger.exception(err) else: print(err)
def test_get_tree_changes_modify(self): """Unit test for get_tree_changes modify.""" # Make a dummy file, stage, commit, modify filename = 'foo' fullpath = os.path.join(self.repo.path, filename) with open(fullpath, 'w') as f: f.write('stuff') porcelain.add(repo=self.repo.path, paths=fullpath) porcelain.commit(repo=self.repo.path, message=b'test status', author=b'author <email>', committer=b'committer <email>') with open(fullpath, 'w') as f: f.write('otherstuff') porcelain.add(repo=self.repo.path, paths=fullpath) changes = porcelain.get_tree_changes(self.repo.path) self.assertEqual(changes['modify'][0], filename.encode('ascii')) self.assertEqual(len(changes['add']), 0) self.assertEqual(len(changes['modify']), 1) self.assertEqual(len(changes['delete']), 0)
def rename_file(self, old_path, new_path): # paths must not be unicode. :( old_files = [old_path] new_files = [new_path] if self.save_script: old_files.append(old_files[0].replace('.ipynb', '.py')) new_files.append(new_files[0].replace('.ipynb', '.py')) git.rm(self._repo, [str(_) for _ in old_files]) renamed = super(GitNotebookManager, self).rename_file(old_path, new_path) git.add(self._repo, [str(_) for _ in new_files]) self.log.debug("Notebook renamed from '%s' to '%s'" % (old_files[0], new_files[0])) git.commit(self._repo, "IPython notebook rename\n\n" "Automated commit from IPython via ipylogue", committer=self.committer_fullname) return renamed
def git_push_to_origin(ui, admin, file_list, message, worker_text): # local_appdata = os.getenv('LOCALAPPDATA') # credentials_file = os.path.join(os.getenv('LOCALAPPDATA'),"LaMA", "credentials","developer_credentials.txt") if admin == True: access_token = get_access_token('developer') else: access_token = get_access_token('user') repo = porcelain.open_repo(database) if admin == True: status = porcelain.status(repo) repo.stage(status.unstaged + status.untracked) # print(status.unstaged) # print(status.untracked) if status.unstaged == [] and status.untracked == []: # information_window("Es wurden keine Änderungen gefunden.") return False for file in file_list: file_path = os.path.join(database, file) porcelain.add(repo, paths=file_path) ui.label.setText("{} (27%)".format(worker_text)) if admin == True: mode = 'Administrator' else: mode = 'User' porcelain.commit(repo, message="New Update ({0}) - {1}".format(mode, message)) ui.label.setText("{} (84%)".format(worker_text)) porcelain.push( repo, "https://*****:*****@github.com/chrisiweb/lama_latest_update.git". format(access_token), "master") ui.label.setText("{} (100%)".format(worker_text)) return True