def create_working_md(sender, instance, created, **kwargs): path = instance.get_path() if created: print 'create sroty' instance.authors.add(instance.owner) instance.save() f = codecs.open(path, encoding='utf-8', mode='w+') f.write(instance.contents) f.seek(0) f.close() from git import Repo, Commit, Actor, Tree author = Actor(instance.owner.username, instance.owner.email) committer = Actor(settings.GIT_COMMITTER['name'], settings.GIT_COMMITTER['email']) # commit if there are any differences repo = Repo.init(settings.GIT_ROOT) # add and commit JUST THIS FILE #tree = Tree(repo=repo, path=instance.owner.profile.get_path()) repo.index.add([instance.owner.profile.get_path()]) repo.index.commit(message=u"saving %s" % instance.title, author=author, committer=committer)
def test_checkout_master(self): if not select_tune_date_update(cnn): date_updated = create_tune_date_update(cnn) git_dir = os.path.join(config.git_folder, cnn.dsn) branch_name = '%s_%s' % ( db_name, date_updated.strftime('%d.%m.%Y_%H.%M') ) # %Y%m%d_%H%M%S repo = clone_or_open_repo(git_dir) past_branch = repo.create_head(branch_name, 'master') repo.head.reference = past_branch repo.head.reset(index=True, working_tree=True) logger.info("checkout new branch %s" % branch_name) # Сохраним тексты df = select_objects_in_folder_or_date_modified( cnn, git_dir, 1, 'd') dirs.write_object_from_df(df, git_dir) # Закомитим # repo.git.add(update=True) repo.git.add(A=True) index = repo.index from git import Actor author = Actor("An author", "*****@*****.**") committer = Actor("A committer", "*****@*****.**") index.commit("my commit message", author=author, committer=committer)
def git_magic(): """ This creates repository on the downloaded and extracted folder. Once that's accomplished, it will push the changes to the repository. Preserving the history of the branch. """ print("Before Git, PATH is: %s." % sys.path) for param in os.environ.keys(): print("%20s %s" % (param, os.environ[param])) import git print("Performing git magic.") source = git.Repo.init(path='/tmp/public') print("Repo initated.") origin = source.create_remote('origin', REPO) origin.fetch() source.head.reset(commit='origin/master') source.heads.master.set_tracking_branch(origin.refs.master) source.heads.master.checkout() source.git.add(A=True) from git import Actor author = Actor(NAME, EMAIL) committer = Actor(NAME, EMAIL) source.index.commit(message='Added new content through AWS Lambda.', author=author, committer=committer) source.git.push() print("Push done.")
def test_commit_authorized_time(self): # repos_dir = r"C:\Users\BryzzhinIS\Documents\Хранилища\sync_script" # repo_dir = os.path.join(repos_dir, 'dbs', 'lw-abs-abs') # repo = clone_or_open_repo(repo_dir) # repo.git.add(A=True) # author = Actor('sources_sync_job', '@mail') # committer = Actor('sources_sync_job', '@mail') # time_str = "2012-07-24T23:14:29-07:00" # time_str = "2012-07-24T23:14:29" # repo.index.commit('test', author=author, committer=committer, author_date=time_str) last_date_update = '28.09.2017 18:30:30' df = select_all_by_date_modified(cnn, last_date_update) df = df.sort_values('MODIFIED', ascending=False) # localtz = pytz.timezone('Europe/Moscow') # time_str = localtz.localize(df.iloc[0]["MODIFIED"]).strftime('%d.%m.%YT%H:%M:%S%z') time_str = (df.iloc[0]["MODIFIED"] + datetime.timedelta(hours=-3)).strftime('%d.%m.%YT%H:%M:%S') print(time_str) repos_dir = r"C:\Users\BryzzhinIS\Documents\Хранилища\sync_script" # repo_dir = os.path.join(repos_dir, 'dbs', 'lw-abs-abs') repo_dir = os.path.join(repos_dir, 'dbs', 'mideveryday') repo = clone_or_open_repo(repo_dir) repo.git.add(A=True) author = Actor('sources_sync_job', '@mail') committer = Actor('sources_sync_job', '@mail') # time_str = "2012-07-24T23:14:29-07:00" # time_str = "2012-07-24T23:14:29" repo.index.commit('test', author=author, committer=committer, author_date=time_str)
def ampq_addFile(id=None, file=None, message=None, branch="master"): repository = get_object_or_404(Repository, pk=id) temp = tempfile.mkdtemp() repo = Repo.clone_from(repository.url, temp, branch=branch) # clone du dépot new_file_path = os.path.join(repo.working_tree_dir, os.path.basename(file.file.name)) fichier = open(new_file_path, 'wb') fichier.write(file.file.read()) fichier.close() repo.index.add([new_file_path]) print(temp + '/' + file.file.name + '/') print(os.path.basename(file.file.name)) print(temp + '/' + os.path.basename(file.file.name)) author = Actor("Utilisateur", "*****@*****.**") committer = Actor("admin la maison des partitions", "*****@*****.**") repo.index.commit(message, author=author, committer=committer) repo.remotes.origin.push() file.file.delete() file.delete() return 1
def get_commit_author(): """get a dictionary that represent the commit author with ``author`` and ``comitter`` key. If there is no users, bot account pk is used. :return: correctly formatted commit author for ``repo.index.commit()`` :rtype: dict """ user = get_current_user() if user and user.is_authenticated(): aut_user = str(user.pk) aut_email = None if hasattr(user, 'email'): aut_email = user.email else: try: aut_user = str( User.objects.filter(username=settings.ZDS_APP['member'] ['bot_account']).first().pk) except AttributeError: aut_user = '******' aut_email = None if aut_email is None or aut_email.strip() == "": aut_email = _(u"inconnu@{}").format(settings.ZDS_APP['site']['dns']) return { 'author': Actor(aut_user, aut_email), 'committer': Actor(aut_user, aut_email) }
def test_build_crash(tmpdir): """ Simulate a runtime error in the build. """ repo = Repo.init(path=tmpdir) tmppath = pathlib.Path(tmpdir) # Write a test file to the repo with open(tmppath / "test.py", "w") as test_txt: test_txt.write("import abc") index = repo.index index.add(["test.py"]) author = Actor("An author", "*****@*****.**") committer = Actor("A committer", "*****@*****.**") index.commit("basic test", author=author, committer=committer) repo.close() import wily.commands.build with patch.object(wily.commands.build.Bar, "finish", side_effect=RuntimeError("arggh")) as bar_finish: runner = CliRunner() result = runner.invoke(main.cli, ["--path", tmpdir, "build", "test.py"]) assert bar_finish.called_once assert result.exit_code == 1, result.stdout
def delete_data(self, repo_path, message, author=None, committer=None): """ Delete a file that's not necessarily a model file. :param str repo_path: Which file to delete. :param str message: The commit message. :param tuple author: The author information (name, email address) Defaults repo default if unspecified. :param tuple committer: The committer information (name, email address). Defaults to the author if unspecified. :returns: The commit """ if not isinstance(message, str): raise StorageException('Messages need to be bytestrings.') file_path = os.path.join(self.repo.working_dir, repo_path) if not os.path.isfile(file_path): raise StorageException('File does not exist.') author_actor = Actor(*author) if author else None committer_actor = Actor(*committer) if committer else author_actor # Remove from the index index = self.repo.index index.remove([file_path], working_tree=True) return index.commit(message, author=author_actor, committer=committer_actor)
def _prepare(cls, create, **kwargs): extract = super(ExtractFactory, cls)._prepare(create, **kwargs) chapter = kwargs.pop('chapter', None) with open(extract.get_path(relative=False), "w") as f: f.write("This dumb content is just here to prove you zep12 is far better than old module") if chapter: if chapter.tutorial: repo = Repo(os.path.join(settings.ZDS_APP['tutorial']['repo_path'], chapter.tutorial.get_phy_slug())) index = repo.index index.add([extract.get_path(relative=True)]) man_path = os.path.join(chapter.tutorial.get_path(), "manifest.json") chapter.tutorial.dump_json(path=man_path) index.add(["manifest.json"]) chapter.tutorial.sha_draft = index.commit( "bla", author=Actor("bla", "*****@*****.**"), committer=Actor("bla", "*****@*****.**")) chapter.tutorial.save() elif chapter.part: repo = Repo(os.path.join(settings.ZDS_APP['tutorial']['repo_path'], chapter.part.tutorial.get_phy_slug())) index = repo.index index.add([extract.get_path(relative=True)]) man_path = os.path.join(chapter.part.tutorial.get_path(), "manifest.json") chapter.part.tutorial.dump_json(path=man_path) index.add(["manifest.json"]) chapter.part.tutorial.sha_draft = index.commit( "bla", author=Actor("bla", "*****@*****.**"), committer=Actor("bla", "*****@*****.**")) chapter.part.tutorial.save() return extract
def test_build(tmpdir): """ Test that build works in a basic repository. """ repo = Repo.init(path=tmpdir) tmppath = pathlib.Path(tmpdir) # Write a test file to the repo with open(tmppath / "test.py", "w") as test_txt: test_txt.write("import abc") with open(tmppath / ".gitignore", "w") as test_txt: test_txt.write(".wily/") index = repo.index index.add(["test.py", ".gitignore"]) author = Actor("An author", "*****@*****.**") committer = Actor("A committer", "*****@*****.**") commit = index.commit("basic test", author=author, committer=committer) with patch("wily.logger") as logger: runner = CliRunner() result = runner.invoke( main.cli, ["--debug", "--path", tmpdir, "build", "test.py"]) assert result.exit_code == 0, result.stdout cache_path = tmpdir / ".wily" assert cache_path.exists() index_path = tmpdir / ".wily" / "git" / "index.json" assert index_path.exists() rev_path = tmpdir / ".wily" / "git" / commit.name_rev.split( " ")[0] + ".json" assert rev_path.exists()
def test_dirty_git(tmpdir): """ Check that repository fails to initialise if unchecked files are in the repo """ repo = Repo.init(path=tmpdir) tmppath = pathlib.Path(tmpdir) index = repo.index author = Actor("An author", "*****@*****.**") committer = Actor("A committer", "*****@*****.**") # First commit with open(tmppath / ".gitignore", "w") as ignore: ignore.write(".wily/") index.add([".gitignore"]) commit1 = index.commit("commit1", author=author, committer=committer) # Write a test file to the repo with open(tmppath / "blah.py", "w") as ignore: ignore.write("*.py[co]\n") index.add(["blah.py"]) repo.close() config = DEFAULT_CONFIG config.path = tmpdir with pytest.raises(DirtyGitRepositoryError): archiver = GitArchiver(config) archiver.revisions(tmpdir, 2)
def get_commit_author(): """get a dictionary that represent the commit author with ``author`` and ``comitter`` key. If there is no users, bot account pk is used. :return: correctly formatted commit author for ``repo.index.commit()`` :rtype: dict """ user = get_current_user() if user and user.is_authenticated: aut_user = str(user.pk) aut_email = None if hasattr(user, "email"): aut_email = user.email else: try: aut_user = str( User.objects.filter(username=settings.ZDS_APP["member"] ["bot_account"]).first().pk) except AttributeError: # if nothing is found, `first` returns None, which does not have attribute pk aut_user = "******" aut_email = None if aut_email is None or not aut_email.strip(): aut_email = _("inconnu@{}").format(settings.ZDS_APP["site"]["dns"]) return { "author": Actor(aut_user, aut_email), "committer": Actor(aut_user, aut_email) }
def test_detached_head(tmpdir): """ Check that repo can initialize in detached head state""" repo = Repo.init(path=tmpdir) tmppath = pathlib.Path(tmpdir) index = repo.index author = Actor("An author", "*****@*****.**") committer = Actor("A committer", "*****@*****.**") # First commit with open(tmppath / "test.py", "w") as ignore: ignore.write("print('hello world')") index.add(["test.py"]) commit1 = index.commit("commit1", author=author, committer=committer) # Second commit with open(tmppath / "test.py", "w") as ignore: ignore.write("print('hello world')\nprint(1)") index.add(["test.py"]) commit2 = index.commit("commit2", author=author, committer=committer) repo.git.checkout(commit2.hexsha) repo.close() config = DEFAULT_CONFIG config.path = tmpdir archiver = GitArchiver(config) assert archiver.revisions(tmpdir, 1) is not None
def ampq_deleteFile(id=None, file=None, message=None, branch="master"): repository = get_object_or_404(Repository, pk=id) temp = tempfile.mkdtemp() # clone du dépot repo = Repo.clone_from(repository.url, temp, branch=branch) # clone du dépot #repo.git.checkout(branch) new_file_path = os.path.join(repo.working_tree_dir, os.path.basename(file.name)) repo.index.remove([new_file_path]) print(temp + '/' + file.name + '/') print(os.path.basename(file.name)) print(temp + '/' + os.path.basename(file.name)) author = Actor("Utilisateur", "*****@*****.**") committer = Actor("admin la maison des partitions", "*****@*****.**") repo.index.commit(str(message), author=author, committer=committer) repo.remotes.origin.push() return 1
def patch_and_push(dfp, repository, target_branch, release_version): """patch the Dockerfile and push the created branch to origin""" # lets create a new branch new_branch = repository.create_head(target_branch) new_branch.checkout() # set dockerfile version to release version dfp.envs['MATTERMOST_VERSION'] = release_version dfp.envs['MATTERMOST_VERSION_SHORT'] = release_version.replace('.', '') # and write back the Dockerfile with open('./mattermost-openshift-workdir/Dockerfile', 'w') as f: f.write(dfp.content) f.close() # commit our work repository.index.add(['Dockerfile']) author = Actor('Mattermost Server Updater Bot', '*****@*****.**') committer = Actor('Mattermost Server Updater Bot', '*****@*****.**') repository.index.commit("Update to Mattermost " + release_version, author=author, committer=committer) # and push to origin with repository.git.custom_environment(GIT_SSH_COMMAND=SSH_CMD): repository.remotes.origin.push( refspec='{}:{}'.format(target_branch, target_branch))
def init_repo(message, bot, path_to_user_folder): try: with open(path_to_user_folder + '/user_data/token.txt', 'r') as f: token = f.read() with Git().custom_environment(HTTPS_REMOTE_URL='https://' + token + ':x-oauth-basic@' + message.text[8:]): repo = Repo.init(path_to_user_folder + '/main') repo.index.add('*') author = Actor("seppass", "*****@*****.**") committer = Actor("seppass", "*****@*****.**") repo.index.commit('initial commit', author=author, committer=committer) origin = repo.create_remote("origin", url='https://' + token + ':x-oauth-basic@' + message.text[8:]) repo.git.push("--set-upstream", origin, repo.head.ref) msg = bot.send_message( message.chat.id, 'Я закончил.', reply_markup=types.ReplyKeyboardRemove(selective=False)) del_mess(msg, bot, 6) return except: msg = bot.send_message( message.chat.id, 'Произошла ошибка.', reply_markup=types.ReplyKeyboardRemove(selective=False)) del_mess(msg, bot, 4) return
async def add_to_index(author_name: Optional[str] = Body(...), author_email: Optional[str] = Body(...), msg: Optional[str] = None): if gitrepo.is_dirty(untracked_files=True): # add the changed files to the index for this commit changedFiles = [item.a_path for item in gitrepo.index.diff(None)] # create a status message num_changed_files = len(changedFiles) num_new_files = len(gitrepo.untracked_files) if msg is None: msg = f"adds {num_changed_files} changed and {num_new_files} new files to repo" # add changed and new files to index for commit gitrepo.index.add(gitrepo.untracked_files) gitrepo.index.add(changedFiles) # set author and committer committer = Actor("file-repo", "*****@*****.**") if author_email is None: author_email = "*****@*****.**" if author_name is None: author_name = "file-repo" author = Actor(f"{author_name}", f"{author_email}") gitrepo.index.commit(msg, author=author, committer=committer) return { "num_changed_files": num_changed_files, "num_new_files": num_new_files, "changed": (num_new_files > 0 or num_changed_files > 0) }
async def change_repo(url): # Remove Default Dockerfile then download New Dockerfile os.remove("Dockerfile") urllib.request.urlretrieve(url, "Dockerfile") # Commit Changes repo = Repo() index = repo.index index.add(["Dockerfile"]) # add a new file to the index from git import Actor author = Actor("Nana", "*****@*****.**") committer = Actor("Nana", "*****@*****.**") # commit by commit message and author and committer index.commit("Change Repo", author=author, committer=committer) if HEROKU_API is not None: import heroku3 heroku = heroku3.from_key(HEROKU_API) heroku_applications = heroku.apps() if len(heroku_applications) >= 1: heroku_app = heroku_applications[0] heroku_git_url = heroku_app.git_url.replace( "https://", "https://*****:*****@" ) if "heroku" in repo.remotes: remote = repo.remote("heroku") remote.set_url(heroku_git_url) else: remote = repo.create_remote("heroku", heroku_git_url) remote.push(refspec="HEAD:refs/heads/master", force=True)
def database_backup(): repo = git.Repo(BACKUP_PATH) origin = repo.remote('origin') origin.pull() try: now = get_time_format() json_name = 'data_{}.json'.format(now) try: cmd = 'python manage.py dumpdata > %s ' % json_name os.system(cmd) except: cmd = 'python3 manage.py dumpdata > %s ' % json_name os.system(cmd) if not os.path.isfile(json_name): return 1 shutil.move(json_name, BACKUP_PATH) author = Actor("taomercy", "*****@*****.**") committer = Actor("taomercy", "*****@*****.**") repo.git.add(os.path.join(BACKUP_PATH, json_name)) if repo.index.diff('HEAD'): commit_msg = 'data backup %s' % now repo.index.commit(commit_msg, author=author, committer=committer) origin.push() else: logging.info("no changes") logging.info('backup end') return 0 except Exception as err: print(repo.git.status()) logging.info(err) return 1
def __init__(self, storage: GitStorage, message: str, author: Tuple[str, str] = None, committer: Tuple[str, str] = None): super().__init__(storage, message) self.author = None if author is None else Actor(*author) self.committer = None if committer is None else Actor(*committer)
def gitdir(tmpdir): """ Create a project and add code to it """ repo = Repo.init(path=tmpdir) tmppath = pathlib.Path(tmpdir) testpath = tmppath / "src" / "test.py" (tmppath / "src").mkdir() # Write a test file to the repo with open(testpath, "w") as test_txt: test_txt.write("import abc") index = repo.index index.add([str(testpath)]) author = Actor("An author", "*****@*****.**") committer = Actor("A committer", "*****@*****.**") index.commit("basic test", author=author, committer=committer) first_test = """ import abc foo = 1 def function1(): a = 1 + 1 class Class1(object): def method(self): b = 1 + 5 """ with open(testpath, "w") as test_txt: test_txt.write(dedent(first_test)) index.add([str(testpath)]) index.commit("add line", author=author, committer=committer) second_test = """ import abc foo = 1 def function1(): a = 1 + 1 class Class1(object): def method(self): b = 1 + 5 if b == 6: return 'banana' """ with open(testpath, "w") as test_txt: test_txt.write(dedent(second_test)) with open(tmppath / ".gitignore", "w") as test_txt: test_txt.write(".wily/") index.add([str(testpath), ".gitignore"]) index.commit("remove line", author=author, committer=committer) return tmpdir
def test_build_twice(tmpdir, cache_path): """ Test that build works when run twice. """ repo = Repo.init(path=tmpdir) tmppath = pathlib.Path(tmpdir) # Write a test file to the repo with open(tmppath / "test.py", "w") as test_txt: test_txt.write("import abc") index = repo.index index.add(["test.py"]) author = Actor("An author", "*****@*****.**") committer = Actor("A committer", "*****@*****.**") commit = index.commit("basic test", author=author, committer=committer) runner = CliRunner() result = runner.invoke( main.cli, [ "--debug", "--path", tmpdir, "--cache", cache_path, "build", "test.py" ], ) assert result.exit_code == 0, result.stdout cache_path = pathlib.Path(cache_path) / "git" assert cache_path.exists() index_path = cache_path / "index.json" assert index_path.exists() rev_path = cache_path / (commit.name_rev.split(" ")[0] + ".json") assert rev_path.exists() # Write a test file to the repo with open(tmppath / "test.py", "w") as test_txt: test_txt.write("import abc\nfoo = 1") index.add(["test.py"]) commit2 = index.commit("basic test", author=author, committer=committer) repo.close() result = runner.invoke(main.cli, ["--debug", "--path", tmpdir, "build", "test.py"]) assert result.exit_code == 0, result.stdout assert cache_path.exists() index_path = cache_path / "index.json" assert index_path.exists() rev_path = cache_path / (commit.name_rev.split(" ")[0] + ".json") assert rev_path.exists() rev_path2 = cache_path / (commit2.name_rev.split(" ")[0] + ".json") assert rev_path2.exists()
def commit(repo, commit_message, cfg): if cfg.username and cfg.usermail: author = Actor(cfg.username, cfg.usermail) else: author = Actor.committer(repo.config_reader()) if cfg.trace: click.echo(f' > Using "{author.name} <{author.email}>" as commit author') repo.index.commit(commit_message, author=author, committer=author)
def commit(date): repo = Repo(search_parent_directories=True) author = Actor('wirbot', '*****@*****.**') committer = Actor('wirbot', '*****@*****.**') repo.git.add('.') repo.index.commit(f'Updates: {date}', author=author, committer=committer) repo.git.push()
def init_repo2(): repo = Repo.init(os.path.join(REPOS_ROOT, "repo2")) repo_file(repo, "bar.txt", "BAR") repo.index.add([os.path.join(repo.working_dir, "bar.txt")]) commit = repo.index.commit("Commit 2", committer=Actor("Committer2", "*****@*****.**"), author=Actor("Author2", "*****@*****.**")) repo.create_head("master2", commit) return IndividualRepo(repo.working_dir, "master2")
def test_git_end_to_end(tmpdir): """ Complete end-to-end test of the git integration """ repo = Repo.init(path=tmpdir) tmppath = pathlib.Path(tmpdir) index = repo.index author = Actor("An author", "*****@*****.**") committer = Actor("A committer", "*****@*****.**") # First commit with open(tmppath / ".gitignore", "w") as ignore: ignore.write(".wily/") index.add([".gitignore"]) commit1 = index.commit("commit1", author=author, committer=committer) # Second commit with open(tmppath / "test.py", "w") as file1: file1.write("print(1)") index.add(["test.py"]) commit2 = index.commit("commit2", author=author, committer=committer) repo.close() config = DEFAULT_CONFIG config.path = tmpdir archiver = GitArchiver(config) assert archiver.config == config revisions = archiver.revisions(tmpdir, 3) assert len(revisions) == 2 assert revisions[0].message == "commit2" assert revisions[0].author_email == "*****@*****.**" assert revisions[0].author_name == "An author" assert ( revisions[0].key in commit2.name_rev and revisions[0].key not in commit1.name_rev ) assert revisions[1].message == "commit1" assert revisions[1].author_email == "*****@*****.**" assert revisions[1].author_name == "An author" assert ( revisions[1].key in commit1.name_rev and revisions[1].key not in commit2.name_rev ) checkout = archiver.checkout(revisions[1], None) assert not (tmppath / "test.py").exists() finish = archiver.finish() assert (tmppath / "test.py").exists()
def make_commits(repo: Repo, commits_data: list, has_mirror: bool = False) -> list: """Loads commit data from JSON file and makes commits in given repo. Args: repo (`Repo`): git repo instance where commits will be made commits_data (list): Contains the commit details to write has_mirror (bool): Indicates whether to write to `.gitchmirror` Returns: list: list of dicts representing commits made """ # Simulate git add-commit workflow for each commit item for i, commit_item in enumerate(commits_data): changes = [] hexsha = commit_item["hexsha"] message = commit_item["message"] commit_dt = datetime.fromtimestamp( commit_item["timestamp"]).isoformat() # Create new file fname = f"{i:05d}.txt" fpath = os.path.join(repo.working_dir, fname) with open(fpath, "w", encoding="utf-8") as f: # Write commit message as file content f.write(message) changes.append(fpath) # Write to .gitchmirror file if has_mirror: gpath = os.path.join(repo.working_dir, GITCHMFILE) with open(gpath, "a+", encoding="utf-8") as g: g.write(f"{hexsha}\n") changes.append(gpath) # Create author and committer author = Actor(name=commit_item["author_name"], email=commit_item["author_email"]) committer = Actor( name=commit_item["committer_name"], email=commit_item["committer_email"], ) # Stage and commit the created file(s) repo.index.add(changes) repo.index.commit( message=message, author=author, author_date=commit_dt, committer=committer, commit_date=commit_dt, ) return commits_data
def add_and_commit(self, repo_dir, filename): author = Actor("teaster", "*****@*****.**") committer = Actor("teaster", "*****@*****.**") repo = Repo('{}/{}'.format(docker_build_dir, repo_dir)) new_file_path = os.path.join(repo.working_tree_dir, filename) repo.index.add([new_file_path]) repo.index.commit("added Dockerfile", author=author, committer=committer)
def test_repo_not_synced(self): index = self.bp_repo.index new_file_path = os.path.join(self.test_dir, "new-file-name") open(new_file_path, "w").close() index.add([new_file_path]) author = Actor("An author", "*****@*****.**") committer = Actor("A committer", "*****@*****.**") index.commit("my commit message", author=author, committer=committer) self.assertFalse(self.bp_repo.is_current_branch_synced())
def test_operator_on_code_with_metric_named_objects(operator, tmpdir): code_with_metric_named_objects = """ # CyclomaticComplexity def complexity(): pass # Halstead def h1(): pass def h2(): pass def N1(): pass def N2(): pass def vocabulary(): pass def length(): pass def volume(): pass def difficulty(): pass def error(): pass # Maintainability def rank(): pass def mi(): pass # RawMetrics def loc(): pass def lloc(): pass def sloc(): pass def comments(): pass def multi(): pass def blank(): pass def single_comments(): pass """ testpath = pathlib.Path(tmpdir) / "test.py" author = Actor("An author", "*****@*****.**") committer = Actor("A committer", "*****@*****.**") with open(testpath, "w") as test_py: test_py.write(dedent(code_with_metric_named_objects)) with Repo.init(path=tmpdir) as repo: repo.index.add(["test.py"]) repo.index.commit("add test.py", author=author, committer=committer) runner = CliRunner() result = runner.invoke( main.cli, ["--debug", "--path", tmpdir, "build", str(testpath), "-o", operator], catch_exceptions=False, ) assert result.exit_code == 0, result.stdout
def test_stats(self): commit = self.rorepo.commit('33ebe7acec14b25c5f84f35a664803fcab2f7781') stats = commit.stats def check_entries(d): assert isinstance(d, dict) for key in ("insertions", "deletions", "lines"): assert key in d # END assertion helper assert stats.files assert stats.total check_entries(stats.total) assert "files" in stats.total for filepath, d in stats.files.items(): check_entries(d) # END for each stated file # assure data is parsed properly michael = Actor._from_string("Michael Trier <*****@*****.**>") assert commit.author == michael assert commit.committer == michael assert commit.authored_date == 1210193388 assert commit.committed_date == 1210193388 assert commit.author_tz_offset == 14400, commit.author_tz_offset assert commit.committer_tz_offset == 14400, commit.committer_tz_offset assert commit.message == "initial project\n"
def test_unicode_actor(self): # assure we can parse unicode actors correctly name = u"Üäöß ÄußÉ" assert len(name) == 9 special = Actor._from_string(u"%s <*****@*****.**>" % name) assert special.name == name assert isinstance(special.name, text_type)
def test_from_string_should_separate_name_and_email(self): a = Actor._from_string("Michael Trier <*****@*****.**>") assert_equal("Michael Trier", a.name) assert_equal("*****@*****.**", a.email) # base type capabilities assert a == a assert not (a != a) m = set() m.add(a) m.add(a) assert len(m) == 1
def newcommit(repo, message, date, name=None, email=None): """Creates a commit object with a custom date. :param repo: Repo object the commit should be part of :param tree: Tree object :param message: Commit message. It may be an empty string if no message is provided. :param date: Date in seconds, as an Int :return: Commit object representing the new commit :note: Additional information about the committer and Author are taken from the git configuration """ tree = repo.index.write_tree() try: parents = [repo.head.commit] except ValueError: parents = [] # Committer and Author info cr = repo.config_reader() if name == None or email == None: actor = Actor.committer(cr) else: actor = Actor(name, email) committer = actor author = actor # Date # offset = altzone # 3600*offsethours offset = 0 # UTC author_time, author_offset = date, offset committer_time, committer_offset = date, offset # assume utf8 encoding enc_section, enc_option = Commit.conf_encoding.split('.') conf_encoding = cr.get_value(enc_section, enc_option, Commit.default_encoding) # Create New Commit new_commit = Commit(repo, Commit.NULL_BIN_SHA, tree, author, author_time, author_offset, committer, committer_time, committer_offset, message, parents, conf_encoding) stream = StringIO() new_commit._serialize(stream) streamlen = stream.tell() stream.seek(0) istream = repo.odb.store(IStream(Commit.type, streamlen, stream)) new_commit.binsha = istream.binsha # Advance HEAD to the new commit automatically. # need late import here, importing git at the very beginning throws. import git.refs try: repo.head.set_commit(new_commit, logmsg="commit: %s" % message) except ValueError: # head is not yet set to the ref our HEAD points to # Happens on first commit import git.refs master = git.refs.Head.create(repo, repo.head.ref, new_commit, logmsg="commit (initial): %s" % message) repo.head.set_reference(master, logmsg='commit: Switching to %s' % master) # END handle empty repositories return new_commit
def test_from_string_should_handle_just_name(self): a = Actor._from_string("Michael Trier") assert_equal("Michael Trier", a.name) assert_equal(None, a.email)
def test_str_should_alias_name(self): a = Actor._from_string("Michael Trier <*****@*****.**>") assert_equal(a.name, str(a))
def test_should_display_representation(self): a = Actor._from_string("Michael Trier <*****@*****.**>") assert_equal('<git.Actor "Michael Trier <*****@*****.**>">', repr(a))