Python Git.init方法代码示例

# 需要导入模块: from git import Git [as 别名]
# 或者: from git.Git import init [as 别名]
    def created_quark(self, sender, new_quark):
        options = sender.options

        if self.git_is_installed():
            g = Git(options['path'])
            g.init()

            default_ignore = os.path.join(os.path.dirname(__file__), '..', 'default_gitignore.txt')
            ignore_path = os.path.join(options['path'], '.gitignore')
            with open(ignore_path, 'w') as ignore_file, open(default_ignore, 'r') as default_file:
                ignore_file.write(default_file.read())
                user_ignores = settings.user_gitignore()
                if user_ignores:
                    ignore_file.write('\n#SUPPLIED FROM ~/.qpmignore\n\n')
                    ignore_file.write(user_ignores)

            g.add(new_quark.get_quarkfile_path(options['path']))
            g.commit(m='Created quarkfile.')

            g.add('.gitignore')
            g.commit(m='Created gitignore.')

            g.add('.')
            if Repo(options['path']).is_dirty():
                g.commit(m='Initial commit of existing files.')

            g.tag(options['version'])

        else:
            self.msg(
                'WARNING: Git is not installed. Try http://git-scm.com/ or run the following:\n'
                + '\truby -e "$(curl -fsSL https://raw.github.com/Homebrew/homebrew/go/install)"; brew install git'
            )

# 需要导入模块: from git import Git [as 别名]
# 或者: from git.Git import init [as 别名]
 def create(cls, path=None, mk_dir=False):
     """
     Initialise the repository WITH a working copy
     """
     if not os.path.exists(path) and mk_dir:
         os.mkdir(path)
     _git = Git(path or os.curdir)
     _git.init()
     return cls(path=path)

# 需要导入模块: from git import Git [as 别名]
# 或者: from git.Git import init [as 别名]
  def initiate(self):
    """ Initiate git repository (or access current) at repoLocation """
    if not os.path.exists(self.repoLocation):
        os.makedirs(self.repoLocation)

    try:
      repo = Repo(self.repoLocation)
    except (InvalidGitRepositoryError, NoSuchPathError, GitCommandError):
      if self.debug: print 'Repository not found at %s:\ncreating repo' % (self.repoLocation)
      git = Git(self.repoLocation)
      git.init()
      repo = Repo(self.repoLocation)

    self.repo = repo

# 需要导入模块: from git import Git [as 别名]
# 或者: from git.Git import init [as 别名]
    def initial(self, prefix):
        """
        Set up the git repo at ``settings.GIT_REPO_PATH``.
        And add initial directory to the repo.

        """
        if not os.path.exists(self.repo_path):
            os.makedirs(self.repo_path)

        try:
            repo = Repo(self.repo_path)
        except (InvalidGitRepositoryError, NoSuchPathError, GitCommandError):
            git = Git(self.repo_path)
            git.init()
            repo = Repo(self.repo_path)

        field_path = os.path.normpath(os.path.join(self.repo_path, prefix))
        if not os.path.exists(field_path):
            os.makedirs(field_path)

# 需要导入模块: from git import Git [as 别名]
# 或者: from git.Git import init [as 别名]
            dirpath = gdir
        else:
            dirpath = gdir + '.git'
    else:
        dirpath = gdir

    if not os.path.isdir(dirpath):
        os.mkdir(dirpath)

    g = Git(dirpath)
    # If is not Git repository, git init
    if not git.repo.fun.is_git_dir(dirpath):

        # bare repository
        if args.__dict__.get('b'):
            repo = g.init(dirpath, bare=True)
        else:
            # local repository
            g.init()
            
            # Make .gitignore
            if not os.path.isfile(dirpath + '/.gitignore'):
                f = open(dirpath + '/.gitignore', 'w')
                f.write('')
                f.close()

            # git add .gitignore and first commit
            if g.untracked_files or g.is_dirty():
                # git add
                g.add('.gitignore')
                # git commit

# 需要导入模块: from git import Git [as 别名]
# 或者: from git.Git import init [as 别名]
class GitFlow(object):
    """
    Creates a :class:`GitFlow` instance.

    :param working_dir:
        The directory where the Git repo is located.  If not specified, the
        current working directory is used.

    When a :class:`GitFlow` class is instantiated, it auto-discovers all
    subclasses of :class:`gitflow.branches.BranchManager`, so there is no
    explicit registration required.
    """

    def _discover_branch_managers(self):
        managers = {}
        for cls in itersubclasses(BranchManager):
            # TODO: Initialize managers with the gitflow branch prefixes
            managers[cls.identifier] = cls(self)
        return managers

    def __init__(self, working_dir='.'):
        # Allow Repos to be passed in instead of strings
        self.repo = None
        if isinstance(working_dir, Repo):
            self.working_dir = working_dir.working_dir
        else:
            self.working_dir = working_dir

        self.git = Git(self.working_dir)
        try:
            self.repo = Repo(self.working_dir)
        except InvalidGitRepositoryError:
            pass

        self.managers = self._discover_branch_managers()
        self.defaults = {
            'gitflow.branch.master': 'master',
            'gitflow.branch.develop': 'develop',
            'gitflow.prefix.versiontag': '',
            'gitflow.origin': 'origin',
        }
        for identifier, manager in self.managers.items():
            self.defaults['gitflow.prefix.%s' % identifier] = manager.DEFAULT_PREFIX

    def _init_config(self, master=None, develop=None, prefixes={}, names={},
                     force_defaults=False):
        for setting, default in self.defaults.items():
            if force_defaults:
                value = default
            elif setting == 'gitflow.branch.master':
                value = master
            elif setting == 'gitflow.branch.develop':
                value = develop
            elif setting.startswith('gitflow.prefix.'):
                name = setting[len('gitflow.prefix.'):]
                value = prefixes.get(name, None)
            else:
                name = setting[len('gitflow.'):]
                value = names.get(name, None)
            if value is None:
                value = self.get(setting, default)
            self.set(setting, value)

    def _init_initial_commit(self):
        master = self.master_name()
        if master in self.repo.branches:
            # local `master` branch exists
            return
        elif self.origin_name(master) in self.repo.refs:
            # the origin branch counterpart exists
            origin = self.repo.refs[self.origin_name(master)]
            branch = self.repo.create_head(master, origin)
            branch.set_tracking_branch(origin)
        elif self.repo.heads:
            raise NotImplementedError(
                'Local and remote branches exist, but neither %s nor %s' % (
                    master, self.origin_name(master)
                ))
        else:
            # Create 'master' branch
            info('Creating branch %r' % master)
            c = self.repo.index.commit('Initial commit', head=False)
            self.repo.create_head(master, c)

    def _init_develop_branch(self):
        # assert master already exists
        assert self.master_name() in self.repo.refs
        develop = self.develop_name()
        if develop in self.repo.branches:
            # local `develop` branch exists, but do not switch there
            return
        if self.origin_name(develop) in self.repo.refs:
            # the origin branch counterpart exists
            origin = self.repo.refs[self.origin_name(develop)]
            branch = self.repo.create_head(develop, origin)
            branch.set_tracking_branch(origin)
        else:
            # Create 'develop' branch
            info('Creating branch %r' % develop)
            branch = self.repo.create_head(develop, self.master())
#.........这里部分代码省略.........

# 需要导入模块: from git import Git [as 别名]
# 或者: from git.Git import init [as 别名]
class GitFlow(object):
    """
    Creates a :class:`GitFlow` instance.

    :param working_dir:
        The directory where the Git repo is located.  If not specified, the
        current working directory is used.

    When a :class:`GitFlow` class is instantiated, it auto-discovers all
    subclasses of :class:`gitflow.branches.BranchManager`, so there is no
    explicit registration required.
    """

    def _discover_branch_managers(self):
        managers = {}
        for cls in itersubclasses(BranchManager):
            # TODO: Initialize managers with the gitflow branch prefixes
            managers[cls.identifier] = cls(self)
        return managers

    def __init__(self, working_dir='.'):
        # Allow Repos to be passed in instead of strings
        self.repo = None
        if isinstance(working_dir, Repo):
            self.working_dir = working_dir.working_dir
        else:
            self.working_dir = working_dir

        self.git = Git(self.working_dir)
        try:
            self.repo = Repo(self.working_dir)
        except InvalidGitRepositoryError:
            pass

        self.managers = self._discover_branch_managers()
        self.defaults = {
            'gitflow.branch.master': 'master',
            'gitflow.branch.develop': 'develop',
            'gitflow.prefix.versiontag': '',
            'gitflow.origin': 'origin',
            'gitflow.release.versionmatcher': '[0-9]+([.][0-9]+){2}',
            }
        for identifier, manager in self.managers.items():
            self.defaults['gitflow.prefix.%s' % identifier] = manager.DEFAULT_PREFIX


    def _init_config(self, master=None, develop=None, prefixes={}, names={},
                     force_defaults=False):
        for setting, default in self.defaults.items():
            if force_defaults:
                value = default
            elif setting == 'gitflow.branch.master':
                value = master
            elif setting == 'gitflow.branch.develop':
                value = develop
            elif setting.startswith('gitflow.prefix.'):
                name = setting[len('gitflow.prefix.'):]
                value = prefixes.get(name, None)
            else:
                name = setting[len('gitflow.'):]
                value = names.get(name, None)
            if value is None:
                value = self.get(setting, default)
            self.set(setting, value)

    def _init_initial_commit(self):
        master = self.master_name()
        if master in self.repo.branches:
            # local `master` branch exists
            return
        elif self.origin_name(master) in self.repo.refs:
            # the origin branch counterpart exists
            origin = self.repo.refs[self.origin_name(master)]
            branch = self.repo.create_head(master, origin)
            branch.set_tracking_branch(origin)
        elif self.repo.heads:
            raise NotImplementedError('Local and remote branches exist, '
                                     'but neither %s nor %s'
                                     % (master, self.origin_name(master) ))
        else:
            # Create 'master' branch
            info('Creating branch %r' % master)
            c = self.repo.index.commit('Initial commit', head=False)
            self.repo.create_head(master, c)

    def _init_develop_branch(self):
        # assert master already exists
        assert self.master_name() in self.repo.refs
        develop = self.develop_name()
        if develop in self.repo.branches:
            # local `develop` branch exists, but do not switch there
            return
        if self.origin_name(develop) in self.repo.refs:
            # the origin branch counterpart exists
            origin = self.repo.refs[self.origin_name(develop)]
            branch = self.repo.create_head(develop, origin)
            branch.set_tracking_branch(origin)
        else:
            # Create 'develop' branch
            info('Creating branch %r' % develop)
#.........这里部分代码省略.........

# 需要导入模块: from git import Git [as 别名]
# 或者: from git.Git import init [as 别名]
class GitModel(QObject) :

    statusRefreshed = Signal(str)

    def __init__(self):
        super(GitModel, self).__init__(None)
        self.configs = dict();
        self.repo = None
        
    def connect(self, path):
        self.repo = Repo(path)
        assert self.repo.bare == False
        
        self.git = Git(path)
        self.git.init()
        
    def run(self, cmd):
        print "run " + str(cmd)
        process = Popen(cmd)
        process.wait()
        print "returncode is " + str(process.returncode)
        return process.returncode
       
    def refreshStatus(self):
        self.status = self.git.status()    
        self.indexModel = self.getIndexModel()
        
        self.statusRefreshed.emit(self.status)
        
    def stageFile(self, path):
        return self.run(['git', 'add', path])
        
    def unstageFile(self, path):
        return self.run(['git', 'reset', 'HEAD', path])

    def executeCommit(self, msg):
        if msg is None or len(msg) == 0:
            print 'Message is empty'
            return -1

        rslt = self.run(['git', 'commit', '-m', msg])

        return rslt
    
    def undoRecentCommit(self):
        rslt = self.run(['git', 'reset', '--soft', 'HEAD^'])        
        return rslt

    def getIndexStatus(self):
        fileIndex = dict()
        
        MODIFIED = '#\tmodified:   '
        RENAMED = '#\trenamed:    '
        NEW_FILE = '#\tnew file:   '
        COMMITTED = '# Changes to be committed:'
        #CHANGED = '# Changed but not updated:'
        CHANGED = '# Changes not staged for commit:'
        UNTRACKED = '# Untracked files:'
        UNTRACKED_INTENT = '#    '
        

        self.isIdxClear = True
        lines = self.status.splitlines()
        type = ''
        for l in lines:
            print l
            
            #index
            if l == COMMITTED :
                type = 'I'
                self.isIdxClear = False
                
            #working directory
            elif l == CHANGED :
                type = 'W'

            if l.startswith(MODIFIED) :
                path = l[len(MODIFIED):]
                
                if type == 'I':
                    fileIndex[path] = 'M'
                elif type == 'W':
                    if path in fileIndex.keys():
                        fileIndex[path] += 'C'
                    else:
                        fileIndex[path] = 'C'
                continue
            
            if l.startswith(RENAMED) :
                path = l[len(RENAMED):].split(' ')[2]               
                fileIndex[path] = 'R'
            
            if l.startswith(NEW_FILE) :
                path = l[len(NEW_FILE):]                
                fileIndex[path] = 'N'                
                
            if l == UNTRACKED :
                type = 'U'
            
                idx = lines.index(l) + 3
#.........这里部分代码省略.........