Ejemplo n.º 1
0
    def start(self, name, starting_point=None):
        """Start a new step (branch)."""

        # make sure this is not a known checkpoint
        if name in self.points():
            raise TutException("Duplicate checkpoint.")

        # make sure the repo is clean
        if self._repo_dirty():
            raise TutException("Dirty tree.")

        # create the new branch
        git.branch(name)

        if starting_point is None:
            args = ('-b', name)
        else:
            args = ('-b', name, starting_point, '--track')

        # add the branch to config
        config = self._config()
        points = config['points']
        if self.current():
            points.insert(points.index(self.current()) + 1, name)
        else:
            points.append(name)

        self._update_config(
            config,
            log='Adding new point %s' % name,
        )

        # checkout the new branch
        git.checkout(name)
        def cleanup_merge():
            git.checkout("master")
            # if something failed, the branch might still exist
            if self.gd.branch_exists("to_merge_1"):
                git.branch("-D", "to_merge_1")

            git.branch("-D", "base_branch")
        def cleanup_merge():
            git.checkout("master")
            # if something failed, the branch might still exist
            if self.gd.branch_exists("to_merge_1"):
                git.branch("-D", "to_merge_1")

            git.branch("-D", "base_branch")
Ejemplo n.º 4
0
    def start(self, name, starting_point=None):
        """Start a new step (branch)."""

        # make sure this is not a known checkpoint
        if name in self.points():
            raise TutException("Duplicate checkpoint.")

        # make sure the repo is clean
        if self._repo_dirty():
            raise TutException("Dirty tree.")

        # create the new branch
        git.branch(name)

        if starting_point is None:
            args = ('-b', name)
        else:
            args = ('-b', name, starting_point, '--track')

        # add the branch to config
        config = self._config()
        points = config['points']
        if self.current():
            points.insert(points.index(self.current()) + 1, name)
        else:
            points.append(name)

        self._update_config(
            config,
            log='Adding new point %s' % name,
        )

        # checkout the new branch
        git.checkout(name)
Ejemplo n.º 5
0
def reply_comment_email(from_email, subject, message):
    try:
        m = re.search('\[(\d+)\-(\w+)\]', subject)
        branch_name = m.group(1)
        article = m.group(2)

        message = decode_best_effort(message)

        # safe logic: no answer or unknown answer is a go for publishing
        if message[:2].upper() == 'NO':
            logger.info('discard comment: %s' % branch_name)
            email_body = get_template('drop_comment').render(original=message)
            mail(pecosys.get_config('post', 'from_email'),
                 pecosys.get_config('post', 'to_email'),
                 'Re: ' + subject, email_body)
        else:
            if pecosys.get_config("git", "disabled"):
                logger.debug("GIT usage disabled (debug mode)")
            else:
                git.merge(branch_name)
                if pecosys.get_config("git", "remote"):
                    git.push()
                logger.info('commit comment: %s' % branch_name)

                # execute post-commit command asynchronously
                postcommand = pecosys.get_config('post', 'postcommand')
                if postcommand:
                    executor.execute(postcommand)

            # send approval confirmation email to admin
            email_body = get_template('approve_comment').render(original=message)
            mail(pecosys.get_config('post', 'from_email'),
                 pecosys.get_config('post', 'to_email'),
                 'Re: ' + subject, email_body)

            # notify reader once comment is published
            reader_email, article_url = get_email_metadata(message)
            if reader_email:
                notify_reader(reader_email, article_url)

            # notify subscribers every time a new comment is published
            notify_subscribers(article)

        if pecosys.get_config("git", "disabled"):
            logger.debug("GIT usage disabled (debug mode)")
        else:
            git.branch("-D", branch_name)
    except:
        logger.exception("new email failure")
Ejemplo n.º 6
0
    def setUp(self):
        super(TestBranch, self).setUp()

        # Build up an interesting mock repo.
        utils_lib.write_file(TRACKED_FP, contents=TRACKED_FP_CONTENTS_1)
        git.add(TRACKED_FP)
        git.commit(TRACKED_FP, m='1')
        utils_lib.write_file(TRACKED_FP, contents=TRACKED_FP_CONTENTS_2)
        git.commit(TRACKED_FP, m='2')
        utils_lib.write_file(UNTRACKED_FP, contents=UNTRACKED_FP_CONTENTS)
        utils_lib.write_file('.gitignore', contents='{0}'.format(IGNORED_FP))
        utils_lib.write_file(IGNORED_FP)
        git.branch(BRANCH)

        self.curr_b = self.repo.current_branch
Ejemplo n.º 7
0
  def setUp(self):
    super(TestBranch, self).setUp()

    # Build up an interesting mock repo.
    utils_lib.write_file(TRACKED_FP, contents=TRACKED_FP_CONTENTS_1)
    git.add(TRACKED_FP)
    git.commit(TRACKED_FP, m='1')
    utils_lib.write_file(TRACKED_FP, contents=TRACKED_FP_CONTENTS_2)
    git.commit(TRACKED_FP, m='2')
    utils_lib.write_file(UNTRACKED_FP, contents=UNTRACKED_FP_CONTENTS)
    utils_lib.write_file('.gitignore', contents='{0}'.format(IGNORED_FP))
    utils_lib.write_file(IGNORED_FP)
    git.branch(BRANCH)

    self.curr_b = self.repo.current_branch
Ejemplo n.º 8
0
    def newest_study_id(self):
        "Return the numeric part of the newest study_id"
        os.chdir(self.repo)

        git.checkout("master")
        dirs = []
        # first we look for studies already in our master branch
        for f in os.listdir("study/"):
            if os.path.isdir("study/%s" % f):
                # ignore alphabetic prefix, o = created by opentree API
                if f[0].isalpha():
                    dirs.append(int(f[1:]))
                else:
                    dirs.append(int(f))

        # next we must look at local branch names for new studies
        # without --no-color we get terminal color codes in the branch output
        branches = git.branch("--no-color")
        branches = [ b.strip() for b in branches ]
        for b in branches:
            mo = re.match(".+_o(\d+)",b)
            if mo:
                dirs.append(int(mo.group(1)))

        dirs.sort()
        return dirs[-1]
Ejemplo n.º 9
0
    def newest_study_id(self):
        "Return the numeric part of the newest study_id"
        os.chdir(self.repo)

        git.checkout("master")
        dirs = []
        # first we look for studies already in our master branch
        for f in os.listdir("study/"):
            if os.path.isdir("study/%s" % f):
                # ignore alphabetic prefix, o = created by opentree API
                if f[0].isalpha():
                    dirs.append(int(f[1:]))
                else:
                    dirs.append(int(f))

        # next we must look at local branch names for new studies
        # without --no-color we get terminal color codes in the branch output
        branches = git.branch("--no-color")
        branches = [b.strip() for b in branches]
        for b in branches:
            mo = re.match(".+_o(\d+)", b)
            if mo:
                dirs.append(int(mo.group(1)))

        dirs.sort()
        return dirs[-1]
Ejemplo n.º 10
0
def check_branch_exists(branch):
    with Spinner(f"Checking for {branch} branch"):
        all_branches = [
            l.strip()
            for l in git.branch(all=True, _tty_out=False).strip().split("\n")
        ]
        for b in all_branches:
            if b.endswith(branch):
                return True
    return False
def delete(version_number):
    heading1("Deleting version " + version_number + "\n")
    cd(base_dir)

    heading2("Removing branch from git.")
    print(git.checkout("master"))
    print(git.branch("-D", version_number))
    print(git.remote("prune", "origin"))

    heading2("Deleting files.")
    print(rm("-rf", base_dir + "/fedora-kickstarts"))
Ejemplo n.º 12
0
def list_branches(package, ignore):
    for name in get_immediate_subdirectories("."):
        if name in packages:
            cd(name)
            branches = sed(git.branch(),
                           r="s/\x1B\[([0-9]{1,2}(;[0-9]{1,2})?)?[m|K]//g")
            branches = [str(branch.strip()) for branch in branches]
            active = [branch for branch in branches if branch[0] == '*'][0]
            active = active.strip("* ")
            if not active in ignore:
                print "{2}: {0} {1}".format(active, branches, name)
            cd("..")
Ejemplo n.º 13
0
    def test_branch_switch_performance(self):
        MAX_TOLERANCE = 100

        gl.commit('f1', m='commit')

        t = time.time()
        gl.branch(c='develop')
        gl.switch('develop')
        gl_t = time.time() - t

        # go back to previous state
        gl.switch('master')

        # do the same for git
        t = time.time()
        git.branch('gitdev')
        git.stash.save('--all')
        git.checkout('gitdev')
        git_t = time.time() - t

        self.assertTrue(gl_t < git_t * MAX_TOLERANCE,
                        msg='gl_t {0}, git_t {1}'.format(gl_t, git_t))
Ejemplo n.º 14
0
  def test_branch_switch_performance(self):
    MAX_TOLERANCE = 100

    gl.commit(o='f1', m='commit')

    t = time.time()
    gl.branch(c='develop')
    gl.switch('develop')
    gl_t = time.time() - t

    # go back to previous state
    gl.switch('master')

    # do the same for git
    t = time.time()
    git.branch('gitdev')
    git.stash.save('--all')
    git.checkout('gitdev')
    git_t = time.time() - t

    self.assertTrue(
        gl_t < git_t*MAX_TOLERANCE,
        msg='gl_t {0}, git_t {1}'.format(gl_t, git_t))
Ejemplo n.º 15
0
    def init(self):
        """Create a new repository with an initial commit."""

        cwd = os.getcwd()

        # initialize the empty repository
        git.init(self.path)
        os.chdir(self.path)

        git.commit(
            m='Initializing empty Tut project.',
            allow_empty=True,
        )

        # create the empty configuration file
        git.branch('tut')
        self._update_config(
            DEFAULT_CONFIG,
            log='Initializing Tut configuration.',
        )
        git.checkout('master')

        os.chdir(cwd)
Ejemplo n.º 16
0
    def init(self):
        """Create a new repository with an initial commit."""

        cwd = os.getcwd()

        # initialize the empty repository
        git.init(self.path)
        os.chdir(self.path)

        git.commit(
            m='Initializing empty Tut project.',
            allow_empty=True,
        )

        # create the empty configuration file
        git.branch('tut')
        self._update_config(
            DEFAULT_CONFIG,
            log='Initializing Tut configuration.',
        )
        git.checkout('master')

        os.chdir(cwd)
Ejemplo n.º 17
0
def auto_update() -> bool:
    """Updates the application from a github repo."""
    add_remote = git.bake('remote', 'add', '-f', '--tags', '-m', 'master',
                          '-t', 'master', 'origin',
                          'https://github.com/threadreaper/autodomme.git')

    if '.git' not in os.listdir(os.getcwd()):
        git('init')
        add_remote()
        git.branch('--set-upstream-to', 'origin/master')
    elif git('remote').exit_code != 0:
        add_remote()
        git.branch('--set-upstream-to', 'origin/master')

    files = [
        line for line in git('--no-pager', 'diff', '--name-only', _iter=True)
    ]
    if files:
        filenames = [filter_filename(file) for file in files[:-1]]
        update_popup(filenames)
        return True
    else:
        return False
Ejemplo n.º 18
0
    def merge(self, branch, base_branch="master"):
        """
        Merge the the given WIP branch to master (or base_branch, if specified)

        If the merge fails, the merge will be aborted
        and then a MergeException will be thrown. The
        message of the MergeException will be the
        "git status" output, so details about merge
        conflicts can be determined.

        """

        os.chdir(self.repo)

        current_branch = self.current_branch()
        if current_branch != base_branch:
            git.checkout(base_branch)

        # Always create a merge commit, even if we could fast forward, so we know
        # when merges occured
        try:
            merge_output = git.merge("--no-ff", branch)
        except sh.ErrorReturnCode:
            # attempt to reset things so other operations can
            # continue
            output = git.status()
            git.merge("--abort")

            # re-raise the exception so other code can decide
            # what to do with it
            raise MergeException(output)

        # the merge succeeded, so remove the local WIP branch
        git.branch("-d", branch)

        new_sha      = git("rev-parse","HEAD")
        return new_sha.strip()
Ejemplo n.º 19
0
    def merge(self, branch, base_branch="master"):
        """
        Merge the the given WIP branch to master (or base_branch, if specified)

        If the merge fails, the merge will be aborted
        and then a MergeException will be thrown. The
        message of the MergeException will be the
        "git status" output, so details about merge
        conflicts can be determined.

        """

        os.chdir(self.repo)

        current_branch = self.current_branch()
        if current_branch != base_branch:
            git.checkout(base_branch)

        # Always create a merge commit, even if we could fast forward, so we know
        # when merges occured
        try:
            merge_output = git.merge("--no-ff", branch)
        except sh.ErrorReturnCode:
            # attempt to reset things so other operations can
            # continue
            output = git.status()
            git.merge("--abort")

            # re-raise the exception so other code can decide
            # what to do with it
            raise MergeException(output)

        # the merge succeeded, so remove the local WIP branch
        git.branch("-d", branch)

        new_sha = git("rev-parse", "HEAD")
        return new_sha.strip()
Ejemplo n.º 20
0
def new_comment(author, email, site, url, article, message,
                subscribe):

    try:
        logger.info("new comment received: author %s url %s subscribe %s"
                    % (author, url, subscribe))

        if site and site[:4] != "http":
            site = "http://" + site

        # Create comment
        now = datetime.now()
        comment_list = (
            'author: %s' % author,
            'email: %s' % email,
            'site: %s' % site,
            'date: %s' % now.strftime("%Y-%m-%d %H:%M:%S"),
            'url: %s' % url,
            'article: %s' % article,
            '',
            '%s' % message,
            ''
        )
        comment = '\n'.join(comment_list)

        logger.debug(comment)

        # Git
        branch_name = now.strftime("%Y%m%d%H%M%S%f")
        if pecosys.get_config("git", "disabled"):
            logger.debug("GIT usage disabled (debug mode)")
        else:
            git.checkout('master')
            if pecosys.get_config("git", "remote"):
                git.pull()

            try:
                git.checkout(branch_name)
            except:
                git.branch(branch_name)
                git.checkout(branch_name)

            comment_filename = 'comment-%s.md' % now.strftime("%Y%m%d-%H%M%S")
            comment_pathname = '%s/%s/%s' % (pecosys.get_config('git', 'comment_path'),
                                             now.year, comment_filename)
            with open(comment_pathname, 'wb') as f:
                f.write(comment.encode('UTF-8'))
            git.add(comment_pathname)
            git.commit('-m', 'new comment')
            git.checkout('master')

        # Render email body template
        email_body = get_template('new_comment').render(url=url, comment=comment)

        # Send email
        mail(pecosys.get_config('post', 'from_email'),
             pecosys.get_config('post', 'to_email'),
             '[' + branch_name + '-' + article + ']',  email_body)

        # Reader subscribes to further comments
        if subscribe and email:
            subscribe_reader(email, article, url)

        logger.debug("new comment processed ")
    except:
        logger.exception("new_comment failure")
 def cleanup_newest():
     git.checkout("master")
     git.branch("-D","leto_study_o9999")
 def tearDownClass(self):
     git.branch("-D",self.testing_branch_name)
 def cleanup_write():
     git.checkout("master")
     git.branch("-D","johndoe_study_9998")
     git.branch("-D","johndoe_study_9999")
 def cleanup_remove():
     git.checkout("master")
     git.branch("-D","johndoe_study_777")
 def cleanup_write():
     git.checkout("master")
     git.branch("-D", "johndoe_study_9998")
     git.branch("-D", "johndoe_study_9999")
Ejemplo n.º 26
0
def current_branch():
    branch = git.branch(show_current=True).strip()
    print(branch)
    return branch
Ejemplo n.º 27
0
    def add_to_blacklist(**kwargs):
        if 'windows' in str(platform.platform()).lower():
            log('warning', "Git support not available in Windows.")
            return (False, "Git support not available in Windows.")

        blacklist = kwargs.get("blacklist", "")
        item_to_blacklist = kwargs.get("item_to_blacklist", "")
        username = kwargs.get("username", "")
        chat_profile_link = kwargs.get("chat_profile_link", "http://chat.stackexchange.com/users")
        code_permissions = kwargs.get("code_permissions", False)

        # Make sure git credentials are set up
        if git.config("--global", "--get", "user.name", _ok_code=[0, 1]) == "":
            return (False, "Tell someone to run `git config --global user.name \"SmokeDetector\"`")

        if git.config("--global", "--get", "user.email", _ok_code=[0, 1]) == "":
            return (False, "Tell someone to run `git config --global user.email \"[email protected]\"`")

        if blacklist == "":
            # If we broke the code, and this isn't assigned, error out before doing anything, but do
            # so gracefully with a nice error message.
            return (False, "Programming Error - Critical information missing for GitManager: blacklist")

        if item_to_blacklist == "":
            # If we broke the code, and this isn't assigned, error out before doing anything, but do
            # so gracefully with a nice error message.
            return (False, "Programming Error - Critical information missing for GitManager: item_to_blacklist")

        item_to_blacklist = item_to_blacklist.replace("\s", " ")

        if blacklist == "website":
            blacklist_file_name = "blacklisted_websites.txt"
            ms_search_option = "&body_is_regex=1&body="
        elif blacklist == "keyword":
            blacklist_file_name = "bad_keywords.txt"
            ms_search_option = "&body_is_regex=1&body="
        elif blacklist == "username":
            blacklist_file_name = "blacklisted_usernames.txt"
            ms_search_option = "&username_is_regex=1&username="******"Invalid blacklist type specified, something has broken badly!")

        git.checkout("master")
        try:
            git.pull()
        except:
            pass

        # Check that we're up-to-date with origin (GitHub)
        git.remote.update()
        if git("rev-parse", "refs/remotes/origin/master").strip() != git("rev-parse", "master").strip():
            return (False, "HEAD isn't at tip of origin's master branch")

        # Check that blacklisted_websites.txt isn't modified locally. That could get ugly fast
        if blacklist_file_name in git.status():  # Also ugly
            return (False, "{0} is modified locally. This is probably bad.".format(blacklist_file_name))

        # Add item to file
        with open(blacklist_file_name, "a+") as blacklist_file:
            last_character = blacklist_file.read()[-1:]
            if last_character != "\n":
                blacklist_file.write("\n")
            blacklist_file.write(item_to_blacklist + "\n")

        # Checkout a new branch (for PRs for non-code-privileged people)
        branch = "auto-blacklist-{0}".format(str(time.time()))
        git.checkout("-b", branch)

        # Clear HEAD just in case
        git.reset("HEAD")

        git.add(blacklist_file_name)
        git.commit("--author='SmokeDetector <*****@*****.**>'",
                   "-m", u"Auto blacklist of {0} by {1} --autopull".format(item_to_blacklist, username))

        if code_permissions:
            git.checkout("master")
            git.merge(branch)
            git.push("origin", "master")
            git.branch('-D', branch)  # Delete the branch in the local git tree since we're done with it.
        else:
            git.push("origin", branch)
            git.checkout("master")

            if GlobalVars.github_username is None or GlobalVars.github_password is None:
                return (False, "Tell someone to set a GH password")

            payload = {"title": u"{0}: Blacklist {1}".format(username, item_to_blacklist),
                       "body": u"[{0}]({1}) requests the blacklist of the {2} {3}. See the Metasmoke search [here]"
                               "(https://metasmoke.erwaysoftware.com/search?utf8=%E2%9C%93{4}{5})\n"
                               u"<!-- METASMOKE-BLACKLIST-{6} {3} -->".format(username, chat_profile_link, blacklist,
                                                                              item_to_blacklist, ms_search_option,
                                                                              item_to_blacklist.replace(" ", "+"),
                                                                              blacklist.upper()),
                       "head": branch,
                       "base": "master"}
            response = requests.post("https://api.github.com/repos/Charcoal-SE/SmokeDetector/pulls",
                                     auth=HTTPBasicAuth(GlobalVars.github_username, GlobalVars.github_password),
                                     data=json.dumps(payload))
            log('debug', response.json())
            try:
                git.checkout("deploy")  # Return to deploy, pending the accept of the PR in Master.
                git.branch('-D', branch)  # Delete the branch in the local git tree since we're done with it.
                return (True, "You don't have code privileges, but I've [created a pull request for you]({0}).".format(
                    response.json()["html_url"]))
            except KeyError:
                git.checkout("deploy")  # Return to deploy

                # Delete the branch in the local git tree, we'll create it again if the
                # command is run again. This way, we keep things a little more clean in
                # the local git tree
                git.branch('-D', branch)

                # Error capture/checking for any "invalid" GH reply without an 'html_url' item,
                # which will throw a KeyError.
                if "bad credentials" in str(response.json()['message']).lower():
                    # Capture the case when GH credentials are bad or invalid
                    return (False, "Something is wrong with the GH credentials, tell someone to check them.")
                else:
                    # Capture any other invalid response cases.
                    return (False, "A bad or invalid reply was received from GH, the message was: %s" %
                            response.json()['message'])

        git.checkout("deploy")  # Return to deploy to await CI.

        return (True, "Blacklisted {0}".format(item_to_blacklist))
def list():
    heading1("Current versions")
    print (git.branch("--list"))

    print(path.dirname(path.realpath(__file__)))
Ejemplo n.º 29
0
def gen_branchs(file_path):
    '''return generator with branchs'''
    branches = git.branch('--all', '--color=never', _cwd=dir_path(file_path))
    return branches
 def tearDownClass(self):
     git.branch("-D", self.testing_branch_name)
 def cleanup_remove():
     git.checkout("master")
     git.branch("-D", "johndoe_study_777")
Ejemplo n.º 32
0
def push(remote_name, remote_branch, to_be_pushed_branch, commit_hash_list):
    git.status()
    current_branch = get_stdout(git('symbolic-ref', '--short', '-q',
                                    'HEAD'))[0:-1]
    mark_message = '***mark***'

    # 校验是否tag已存在
    tag_name = f"merging({current_branch}-->{remote_name}/{remote_branch})"
    code, output = subprocess.getstatusoutput(f"git tag | grep '^{tag_name}$'")
    if code == 0:
        print(f"错误,tag:{tag_name} 已存在")
        exit(-1)

    # 校验远程分支是否存在
    code, output = subprocess.getstatusoutput('git fetch')
    if code != 0:
        print(output)
        print("fetch 失败")
        exit(-1)

    code, output = subprocess.getstatusoutput(
        f"git branch -r | cat | grep '^ *{remote_name}/{remote_branch}'")
    if code != 0:
        print("错误,远程分支%s不存在" % remote_branch)
        exit(-1)

    # 如果工作区不干净,mark提交
    res = git.status()
    is_clean = re.match(".*nothing to commit, working tree clean.*",
                        get_stdout(res), re.S)
    if not is_clean:
        print('工作区不干净,mark提交...')
        git.add('--all')
        git.commit('-a', '-m', mark_message)

    # 检出到远程临时分支
    tmp_branch = f'tmp/local_{remote_name}_{remote_branch}'
    print(f'检出到远程临时分支"{tmp_branch}"...')
    git.checkout('-b', tmp_branch, f'{remote_name}/{remote_branch}')

    # cherry-pick
    try:
        print('开始cherry-pick...')
        res = git('cherry-pick', commit_hash_list)
    except sh.ErrorReturnCode_1:
        print(get_stderr(res))
        print("请解决冲突,然后选择后续操作...")
        while True:
            operation = input('请输入处理方式')
            if operation == 0:
                print('execute: git cherry-pick --continue...')
                code, output = subprocess.getstatusoutput(
                    'git cherry-pick --continue')
                print(output)
                if code != 0:
                    continue
                else:
                    print('解决冲突成功')
                    break
            elif operation == 1:
                print('退出,停在当前位置')
                git('check-pick', '--abort')
                exit(-1)
            elif operation == 2:
                print('撤销,回到起点...')
                git('check-pick', '--abort')
                # 切换会原来的分支,并去掉mark提交
                git.switch(current_branch)
                git.branch('-D', tmp_branch)
                de_mark_commit(current_branch, mark_message)
                exit(-1)
            else:
                print('输入不合法,请重新输入')
    except ErrorReturnCode:
        print(get_stderr(res))
        exit(-1)

    print('推送中...')
    git.push('-f', remote_name, f'HEAD:{to_be_pushed_branch}')

    # 切换会原来的分支,并去掉mark提交
    print('切换会原来的分支,并去掉mark提交')
    git.switch(current_branch)
    git.branch('-D', tmp_branch)
    de_mark_commit(current_branch, mark_message)

    print(f'添加tag"{tag_name}"...')
    git.tag('-a', tag_name, '-m', "nothing")
    print('完成!')
Ejemplo n.º 33
0
def clean():
    if path.exists('dist'):
        rmtree('dist')


vers = input('Did you change the version? (y/n) ')
if vers != 'y' and vers != 'n':
    print('Expected "y" or "n", instead found {}. Exiting.'.format(vers))
    exit(1)

if vers == 'n':
    exit(0)

status = git.status()
branch = git.branch()

if 'master' not in branch:
    print('Must be on branch "master". Exiting.')
    exit(1)

if 'Changes not staged for commit' in status or 'Untracked files' in status or 'Changes to be committed' in status:
    # get user input for if they want to commit all current changes
    # and continue with the deploy script
    # exit if no
    commit = input(
        'Changes were detected, would you like to commit all current changes? (y/n) '
    )
    if commit != 'y' and commit != 'n':
        print('Expected "y" or "n", instead found {}. Exiting.'.format(commit))
        exit(1)
Ejemplo n.º 34
0
	# All operation succeed for the current compiled version.
	branch.writeCachedHash()

	return True

if "branch" in sys.argv:
	#client = IrcClient()
	cd(blenderSourceDir)
	git.remote("prune", "origin")
	git.pull("--rebase")
	git.remote("prune", "origin")

	if "--branch" in sys.argv:
		branchNames = [sys.argv[sys.argv.index("--branch") + 1]]
	else:
		branchNames = str(git.branch("--all", "--color=never")).split(" ")
		branchNames = [name[15:-1] for name in branchNames if name.startswith("remotes/origin") and name != "remotes/origin/HEAD"]

	with open(branchMaskFile, "a+") as mask:
		mask.seek(0)
		maskBranch = [line[:-1] for line in mask.readlines()]
		for branchName in branchNames:
			if not os.path.exists(prefixSourceDir + "blender_" + branchName) and not branchName in maskBranch:
				while True:
					answer = input("Do you want mask branch " + branchName + "? (y/n): ")
					if answer == "y":
						mask.write(branchName + "\n")
						break;
					elif answer == "n":
						break;
Ejemplo n.º 35
0
def main():
    searchDir(sys.argv[1])
    print(git.branch("-v"))
 def cleanup_newest():
     git.checkout("master")
     git.branch("-D", "leto_study_o9999")
Ejemplo n.º 37
0
def gen_branchs(file_path):
    '''return generator with branchs'''
    branches = git.branch('--all', '--color=never', _cwd=dir_path(file_path))
    return branches