Merge the current branch into master.
423082
def merge(config):
    """"""
    repo = config.repo

    active_branch = repo.active_branch
    if active_branch.name == "master":
        error_out("You're already on the master branch.")

    if repo.is_dirty():
        error_out(
            'Repo is "dirty". ({})'.format(
                ", ".join([repr(x.b_path) for x in repo.index.diff(None)])
            )
        )

    branch_name = active_branch.name

    state = read(config.configfile)
    origin_name = state.get("ORIGIN_NAME", "origin")
    upstream_remote = None
    for remote in repo.remotes:
        if remote.name == origin_name:
            upstream_remote = remote
            break
    if not upstream_remote:
        error_out("No remote called {!r} found".format(origin_name))

    repo.heads.master.checkout()
    upstream_remote.pull(repo.heads.master)

    repo.git.merge(branch_name)
    repo.git.branch("-d", branch_name)
    success_out("Branch {!r} deleted.".format(branch_name))

    info_out("NOW, you might want to run:\n")
    info_out("git push origin master\n\n")

    push_for_you = input("Run that push? [Y/n] ").lower().strip() != "n"
    if push_for_you:
        upstream_remote.push("master")
        success_out("Current master pushed to {}".format(upstream_remote.name))
567740
def join(self):
        """"""
        self._root_state.join()
        # execution finished, close execution history log file (if present)
        if len(self._execution_histories) > 0:
            if self._execution_histories[-1].execution_history_storage is not None:
                set_read_and_writable_for_all = global_config.get_config_value("EXECUTION_LOG_SET_READ_AND_WRITABLE_FOR_ALL", False)
                self._execution_histories[-1].execution_history_storage.close(set_read_and_writable_for_all)
        from rafcon.core.states.state import StateExecutionStatus
        self._root_state.state_execution_status = StateExecutionStatus.INACTIVE
997353
def merge(base, opts= {})
      logger.info { "Merging #{branches.current.name} with #{base}" }
      args = []
      args << '-s' << opts[:merge_strategy] if opts[:merge_strategy]
      args << base
      return command(:merge, args)
    end
1131995
public function merge(self $that)
    {
        $this->statements += $that->statements;
        $this->coveredStatements += $that->coveredStatements;
        $this->lineCoverage = null; // clear previous data
    }
436669
protected synchronized void merge(DoubleMinMax minmax) {
    this.minmax.put(minmax.getMin());
    this.minmax.put(minmax.getMax());
  }
751763
public void merge(Model target, BioPAXElement source)
	{
		merge(target, Collections.singleton(source));
	}
1352186
public void consolidate() {
		Decl.Module module = target.getModule();
		for(ExternalGroup group : consolidations) {
			// TODO: this could be made way more efficient by collecting all consolidate
			// units into one batch
			module.putExtern(group.consolidate());
		}
		consolidations.clear();
	}
97589
function merge (target, source) {
  source = source || {};
  return Object.keys(source).reduce((targetKey, key) => {
    targetKey[key] = source[key];
    return target;
  }, target);
}
1296062
def finish(self):
        
        self.repo.git.checkout(self.current_branch)
        self.repo.close()
754921
def merge(revision, branch_label, message, list_revisions=''):
    
    alembic_command.merge(
        config=get_config(),
        revisions=list_revisions,
        message=message,
        branch_label=branch_label,
        rev_id=revision
    )
1061185
def merge(a, b):
    
    if isinstance(a, CONFIG_VALID) \
            and isinstance(b, CONFIG_VALID):
        # dict update
        if isinstance(a, dict) and isinstance(b, dict):
            a.update(b)
            return a
        # list update
        _a = list(a)
        for x in list(b):
            if x not in _a:
                _a.append(x)
        return _a
    if a and b:
        raise Exception("Cannot merge")
    raise NotImplementedError
122987
def merge(subtree, prefix, name, options = {})
      register(prefix, name, options)
      subtree.calls.each do |key, command|
        next unless command

        calls["#{prefix}#{key}"] = command
      end
    end
610160
def merge(self, another):
        
        if isinstance(another, Result):
            another = another.errors
        self.errors = self.merge_errors(self.errors, another)
1236738
private void mergeForceCollapse() {
        while (stackSize > 1) {
            int n = stackSize - 2;
            if (n > 0 && runLen[n - 1] < runLen[n + 1])
                n--;
            mergeAt(n);
        }
    }
1315858
def _merge(x, y):
    """"""
    merged = {**x, **y}

    xkeys = x.keys()

    for key in xkeys:
        if isinstance(x[key], dict) and key in y:
            merged[key] = _merge(x[key], y[key])

    return merged
122694
def merge(self, other):
        """"""
        if not isinstance(other, Berksfile):
            raise TypeError("Berksfile to merge should be a 'Berksfile' "
                            "instance, not %s.", type(other))
        current = self.to_dict()
        new = other.to_dict()

        # compare and gather cookbook dependencies
        berks_writelines = ['%s\n' % self.cookbook_statement(cbn, meta)
                            for cbn, meta in new.get('cookbook', {}).items()
                            if cbn not in current.get('cookbook', {})]

        # compare and gather 'source' requirements
        berks_writelines.extend(["source '%s'\n" % src for src
                                 in new.get('source', [])
                                 if src not in current.get('source', [])])

        self.write_statements(berks_writelines)
        return self.to_dict()
606156
def merged():
    # type: () -> None
    
    develop = conf.get('git.devel_branch', 'develop')
    branch = git.current_branch(refresh=True)

    common.assert_branch_type('feature')

    # Pull develop with the merged feature
    common.git_checkout(develop)
    common.git_pull(develop)

    # Cleanup
    common.git_branch_delete(branch.name)
    common.git_prune()

    common.git_checkout(develop)