Python pygit2.init_repository函数代码示例

def init_repo(repo_path, clone_from=None, clone_refs=False,
              alternate_repo_paths=None, is_bare=True):
    """Initialise a new git repository or clone from existing."""
    assert is_valid_new_path(repo_path)
    init_repository(repo_path, is_bare)

    if clone_from:
        # The clone_from's objects and refs are in fact cloned into a
        # subordinate tree that's then set as an alternate for the real
        # repo. This lets git-receive-pack expose available commits as
        # extra haves without polluting refs in the real repo.
        sub_path = os.path.join(repo_path, 'turnip-subordinate')
        clone_repository(clone_from, sub_path, True)
        assert is_bare
        alt_path = os.path.join(repo_path, 'objects/info/alternates')
        with open(alt_path, 'w') as f:
            f.write('../turnip-subordinate/objects\n')

        if clone_refs:
            # With the objects all accessible via the subordinate, we
            # can just copy all refs from the origin. Unlike
            # pygit2.clone_repository, this won't set up a remote.
            # TODO: Filter out internal (eg. MP) refs.
            from_repo = Repository(clone_from)
            to_repo = Repository(repo_path)
            for ref in from_repo.listall_references():
                to_repo.create_reference(
                    ref, from_repo.lookup_reference(ref).target)

    if alternate_repo_paths:
        write_alternates(repo_path, alternate_repo_paths)
    ensure_config(repo_path)  # set repository configuration defaults
    return repo_path

def _init(victim, str_victim):
    try:
        rmtree(str_victim)
    except OSError:
        pass
    victim.mkdir()
    init_repository(str_victim)

    def initial(self, prefix):
        """
        Set up the git repo at ``settings.GIT_REPO_PATH``.
        And add initial directory to the repo.

        """
        pygit2.init_repository(self.repo_path, True)  # a bare repository

    def test_011_storage_empty_basic(self):
        emptydir = join(self.testdir, 'empty')

        init_repository(join(emptydir, '.git'), bare=True)

        item = DummyItem(emptydir)
        storage = GitStorage(item)
        self.assertEqual(storage.files(), [])

        pathinfo = storage.pathinfo('')
        self.assertEqual(pathinfo, {
            'basename': '',
            'date': '',
            'size': 0,
            'type': 'folder',
        })

        result = list(storage.listdir(''))
        self.assertEqual(result, [])

        result = storage.log(None, 1)
        self.assertEqual(result, [])

        self.assertEqual(storage.shortrev, None)
        self.assertEqual(storage.rev, None)

def repositories():
    if request.method == 'POST':
        username = 'baijian'
        reponame = request.form['reponame']
        repodesc = request.form['repodesc']
        init_repository('/home/git/repositories/' + username + '/' + reponame, True)
        return redirect(url_for('.index', name=username, reponame=reponame))

 def init_backend(cls, path, fields, init=False, soft=False):
     # Metadata database
     init_repository('{0}/database'.format(path), bare=False)
     lfs.make_folder('{0}/database/.git/patchs'.format(path))
     cls.init_backend_static(path)
     # Make catalog
     make_catalog('{0}/catalog'.format(path), fields)

  def prepare_backup_folder(self):
    print("Preparing backup folder : ", self.container)
    os.mkdir(self.container)
    pygit2.init_repository(self.container, False)

    # look for the restore script in the default install dir first
    try:
      shutil.copy2("/usr/share/pacbackup/pacrestore.sh", self.container)
    except FileNotFoundError:
      try:
        shutil.copy2(os.path.join(os.path.dirname(os.path.realpath(__file__)),
          "pacrestore.sh"), self.container)
      except FileNotFoundError:
        print("Couldn't find the restore script anywhere, try reinstalling", file=stderr)
        shutil.rmtree(self.container)
        exit()

    repo = pygit2.Repository(self.container)
    index = repo.index

    index.read()
    index.add_all()
    index.write()
    tree = index.write_tree()

    message = "Initial Commit - Automated Package List Backup"
    comitter = pygit2.Signature('PacBackup '+__version__, '')
    sha = repo.create_commit('HEAD', 
      comitter, comitter, message, 
      tree, 
      [])

 def init(self):
     pygit2.init_repository(self.dir)
     os.makedirs(self.md_path)
     os.makedirs(self.generate_path)
     self.config = config.Config(self.dir)
     for file in resources.INIT_FILES:
         with open(os.path.join(self.dir, file), "w+") as f:
             f.write(resources.INIT_FILES[file])

 def __init__(self, path):
     # TODO path should probably be a resource, ie redis url etc.
     self.path = path
     self.object_root = os.path.join(self.path, "objects")
     if not os.path.exists(self.object_root):
         log.info("initializing database in %s" % (path))
         pygit2.init_repository(path, True)
     self.repo = pygit2.Repository(path)
     self.check_repo_sanity()

    def initialise(self, new_remote=None):
        """Setup the .git folder, with optional remote"""
        log.info("Setting up a .git folder")
        git_folder = os.path.join(self.location, ".git")
        if os.path.exists(git_folder):
            raise GitError("Trying to initialise git, but .git folder already exists", location=self.location)

        pygit2.init_repository(self.location)
        self.add_change("Initial commit", changed_files=True)
        if new_remote:
            self.change_remote(new_remote)

 def setUp(self):
     self.repo_path = mkdtemp()
     init_repository(self.repo_path, False)
     self.repo = Repository(self.repo_path)
     self.file_name = 'foo.rst'
     self.file_path = os.path.join(self.repo_path, self.file_name)
     with codecs.open(self.file_path, 'w', encoding='utf-8') as fp:
         fp.write('test\n')
     self.tree = self.repo.TreeBuilder()
     self.last_commit = git_commit(self.repo, self.tree, [self.file_name])
     self.changectx = self.repo.head

    def setUp(self):

        self.dir = TemporaryDirectory()
        self.remotedir = TemporaryDirectory()
        self.file = NamedTemporaryFile(dir=self.dir.name, delete=False)
        self.filename = path.basename(self.file.name)
        self.author = Signature('QuitStoreTest', '[email protected]')
        self.comitter = Signature('QuitStoreTest', '[email protected]')

        # Initialize repository
        init_repository(self.dir.name, False)

def create_projects_git(folder, bare=False):
    """ Create some projects in the database. """
    repos = []
    for project in ['test.git', 'test2.git']:
        repo_path = os.path.join(folder, project)
        repos.append(repo_path)
        if not os.path.exists(repo_path):
            os.makedirs(repo_path)
        pygit2.init_repository(repo_path, bare=bare)

    return repos

    def create_storage(cls, path):
        """
            Create repository, and return GitStorage object on it

            :param path: Absolute path to the Git repository to create.
            :type path: str
            :returns: GitStorage
        """

        init_repository(path, False)

        return cls(path)

def create_git_repo(name, gitfolder):
    # Create a git project based on the package information.
    # get the path of the git repo
    gitrepo = os.path.join(gitfolder, '%s.git' % name)

    if os.path.exists(gitrepo):
        raise fresque.exceptions.RepoExistsException(
            'The project named "%s" already have '
            'a git repository' % name
        )
    # create a bare git repository
    pygit2.init_repository(gitrepo, bare=True)
    return 'Successfully created Project {0} git respository'.format(name)