def commit_multi(proj, asset, filenames, text, username=None):
    """Commit multiple files to the repository and returns the revision id."""
    repo_path = os.path.join(G.REPOSITORY, proj)
    repo = repo_get(proj)
    
    if not isinstance(filenames, list):
        raise SPAMRepoError('expected a list of files for asset %s' % asset.id)

    text = 'asset %s - %s' % (asset.id, text)
    encodedtext = text.encode('utf-8')
    target_sequence_path = asset.path.replace('#', '%04d')
    targets = []
    
    for i, filename in enumerate(filenames):
        n = i + 1
        uploadedfile = os.path.join(G.UPLOAD, filename)
        target_path = (target_sequence_path % n).encode()
        target_repo_path = os.path.join(repo_path, target_path)
        if not os.path.exists(os.path.dirname(target_repo_path)):
            os.makedirs(os.path.dirname(target_repo_path))
        shutil.move(uploadedfile, target_repo_path)
        
        if not target_path in repo['tip']:
            commands.add(repo_ui, repo, target_repo_path)
    
        targets.append(target_path)
        
    matched = match.exact(repo.root, repo.getcwd(), targets)
    commit_id = repo.commit(encodedtext, user=username, match=matched)
    if commit_id:
        return repo[commit_id].hex()
    else:
        return None

    def test_branch(self):
        ''' Test 'clone --branch' '''
        ui = self.ui()
        _dispatch(ui, ['init', self.wc_path])
        repo = self.repo
        repo.ui.setconfig('ui', 'username', 'anonymous')

        fpath = os.path.join(self.wc_path, 'it')
        f = file(fpath, 'w')
        f.write('C1')
        f.flush()
        commands.add(ui, repo)
        commands.branch(ui, repo, label="B1")
        commands.commit(ui, repo, message="C1")
        f.write('C2')
        f.flush()
        commands.branch(ui, repo, label="default")
        commands.commit(ui, repo, message="C2")
        f.write('C3')
        f.flush()
        commands.branch(ui, repo, label="B2")
        commands.commit(ui, repo, message="C3")

        self.assertEqual(len(repo), 3)

        branch = 'B1'
        _dispatch(ui, ['clone', self.wc_path, self.wc_path + '2',
                                '--branch', branch])

        repo2 = hg.repository(ui, self.wc_path + '2')

        self.assertEqual(repo[branch].hex(), repo2['.'].hex())

    def endWrite(self, withErrors):
        """Called when PUT has finished writing.

        See DAVResource.endWrite()
        """
        if not withErrors:
            commands.add(self.provider.ui, self.provider.repo, self.localHgPath)

 def test_reload_changectx_working_dir(self):
     app = create_app(repo_path=self.repo_path,
                      revision_id=REVISION_WORKING_DIR)
     client = app.test_client()
     rv = client.get('/')
     self.assertTrue('post/lorem-ipsum' in rv.data)
     self.assertTrue('post/example-post' in rv.data)
     commands.add(self.ui, self.repo)
     rv = client.get('/')
     self.assertTrue('post/lorem-ipsum' in rv.data)
     self.assertTrue('post/example-post' in rv.data)
     commands.commit(self.ui, self.repo, message='foo', user='foo')
     rv = client.get('/')
     self.assertTrue('post/lorem-ipsum' in rv.data)
     self.assertTrue('post/example-post' in rv.data)
     with codecs.open(os.path.join(self.repo_path,
                                   app.config['CONTENT_DIR'], 'about.rst'),
                      'a', encoding='utf-8') as fp:
         fp.write('\n\nTHIS IS A TEST!\n')
     rv = client.get('/about/')
     self.assertTrue('THIS IS A TEST!' in rv.data)
     commands.commit(self.ui, self.repo, message='foo', user='foo')
     rv = client.get('/about/')
     self.assertTrue('THIS IS A TEST!' in rv.data)
     with codecs.open(os.path.join(self.repo_path,
                                   app.config['CONTENT_DIR'], 'about.rst'),
                      'a', encoding='utf-8') as fp:
         fp.write('\n\nTHIS IS another TEST!\n')
     rv = client.get('/about/')
     self.assertTrue('THIS IS another TEST!' in rv.data)
     commands.commit(self.ui, self.repo, message='foo', user='foo')
     rv = client.get('/about/')
     self.assertTrue('THIS IS another TEST!' in rv.data)

    def test_update(self):
        ''' Test 'clone --updaterev' '''
        ui = self.ui()
        _dispatch(ui, ['init', self.wc_path])
        repo = self.repo
        repo.ui.setconfig('ui', 'username', 'anonymous')

        fpath = os.path.join(self.wc_path, 'it')
        f = file(fpath, 'w')
        f.write('C1')
        f.flush()
        commands.add(ui, repo)
        commands.commit(ui, repo, message="C1")
        f.write('C2')
        f.flush()
        commands.commit(ui, repo, message="C2")
        f.write('C3')
        f.flush()
        commands.commit(ui, repo, message="C3")

        self.assertEqual(len(repo), 3)

        updaterev = 1
        _dispatch(ui, ['clone', self.wc_path, self.wc_path + '2',
                                '--updaterev=%s' % updaterev])

        repo2 = hg.repository(ui, self.wc_path + '2')

        self.assertEqual(str(repo[updaterev]), str(repo2['.']))

 def create_test_changesets(self, repo, count=1, dates=[]):
     for i in range(count):
         filename = repo_test_utils._create_random_file(self.directory)
         commands.add(repo.get_ui(), repo.get_repo(), filename)
         
         date=None
         if i < len(dates):
             date=dates[i]
         commands.commit(repo.get_ui(), repo.get_repo(), date=date, message="creating test commit", user='Test Runner <[email protected]>')

    def hg_add(self, single=None):
        """Adds all files to Mercurial when the --watch options is passed
        This only happens one time. All consequent files are not auto added
        to the watch list."""
        repo = hg.repository(ui.ui(), self.path)
        if single is None:
            commands.add(ui.ui(), repo=repo)
            hg_log.debug('added files to repo %s' % self.path)

        else:
            commands.add(ui.ui(), repo, single) 
            hg_log.debug('added files to repo %s' % self.path)

    def commit_results(self, msg_id, submission_tuple, results):
        """ INTERNAL: Commit the results of a submission to the local repo. """

        print "RESULTS: ", results
        if len(results[3]) > 0 and sum([len(results[index]) for index in
                                        (0, 1, 2, 4)]) == 0: #HACK, fix order!
            raise NoChangesError()

        assert sum([len(results[index]) for index in (0, 1, 2, 4)]) > 0

        wikitext_dir = os.path.join(self.full_base_path(), 'wikitext')
        raised = True
        # grrr pylint gives spurious
        #pylint: disable-msg=E1101
        self.ui_.pushbuffer()
        try:
            # hg add new files.
            for name in results[0]:
                full_path = os.path.join(wikitext_dir, name)
                commands.add(self.ui_, self.repo, full_path)

            # hg add fork files
            for name in results[4]:
                full_path = os.path.join(wikitext_dir, name)
                commands.add(self.ui_, self.repo, full_path)

            # hg remove removed files.
            for name in results[2]:
                full_path = os.path.join(wikitext_dir, name)
                commands.remove(self.ui_, self.repo, full_path)

            # Writes to/prunes special file used to generate RemoteChanges.
            self.update_change_log(msg_id, submission_tuple, results, True)

            # REDFLAG: LATER, STAKING? later allow third field for staker.
            # fms_id|chk
            commit_msg = "%s|%s" % (submission_tuple[0],
                                    submission_tuple[3])
            # hg commit
            commands.commit(self.ui_, self.repo,
                            logfile=None, addremove=None, user=None,
                            date=None,
                            message=commit_msg)
            self.fixup_accepted_log() # Fix version in accepted.txt
            self.notify_committed(True)
            raised = False
        finally:
            text = self.ui_.popbuffer()
            if raised:
                self.logger.debug("commit_results -- popped log:\n%s" % text)

 def createCollection(self, name):
     """Create a new collection as member of self.
     
     A dummy member is created, because Mercurial doesn't handle folders.
     """
     assert self.isCollection
     self._checkWriteAccess()
     collpath = self._getFilePath(name)
     os.mkdir(collpath)
     filepath = self._getFilePath(name, ".directory")
     f = open(filepath, "w")
     f.write("Created by WsgiDAV.")
     f.close()
     commands.add(self.provider.ui, self.provider.repo, filepath)

    def setUp(self):
        self.repo_path = mkdtemp()
        self.ui = ui.ui()
        self.ui.setconfig('ui', 'username', 'foo <[email protected]>')
        self.ui.setconfig('ui', 'quiet', True)
        commands.init(self.ui, self.repo_path)
        self.repo = hg.repository(self.ui, self.repo_path)
        file_dir = os.path.join(self.repo_path, 'content')
        if not os.path.isdir(file_dir):
            os.makedirs(file_dir)
        for i in range(3):
            file_path = os.path.join(file_dir, 'page-%i.rst' % i)
            with codecs.open(file_path, 'w', encoding='utf-8') as fp:
                fp.write(SAMPLE_PAGE)
            commands.add(self.ui, self.repo, file_path)
        file_path = os.path.join(file_dir, 'about.rst')
        with codecs.open(file_path, 'w', encoding='utf-8') as fp:
            fp.write(SAMPLE_PAGE + """
.. aliases: 301:/my-old-post-location/,/another-old-location/""")
        commands.add(self.ui, self.repo, file_path)
        file_dir = os.path.join(self.repo_path, 'content', 'post')
        if not os.path.isdir(file_dir):
            os.makedirs(file_dir)
        for i in range(3):
            file_path = os.path.join(file_dir, 'post-%i.rst' % i)
            with codecs.open(file_path, 'w', encoding='utf-8') as fp:
                fp.write(SAMPLE_POST)
            commands.add(self.ui, self.repo, file_path)
        file_path = os.path.join(file_dir, 'foo.rst')
        with codecs.open(file_path, 'w', encoding='utf-8') as fp:
            # using the page template, because we want to set tags manually
            fp.write(SAMPLE_PAGE + """
.. tags: foo, bar, lol""")
        commands.add(self.ui, self.repo, file_path)
        commands.commit(self.ui, self.repo, message='foo', user='foo')

    def createEmptyResource(self, name):
        """Create and return an empty (length-0) resource as member of self.
        
        See DAVResource.createEmptyResource()
        """
        assert self.isCollection
        self._checkWriteAccess()    
        filepath = self._getFilePath(name)
        f = open(filepath, "w")
        f.close()
        commands.add(self.provider.ui, self.provider.repo, filepath)
        # getResourceInst() won't work, because the cached manifest is outdated 
#        return self.provider.getResourceInst(self.path.rstrip("/")+"/"+name, self.environ)
        return HgResource(self.path.rstrip("/")+"/"+name, False, 
                          self.environ, self.rev, self.localHgPath+"/"+name)

 def test_reload_changectx_default(self):
     app = create_app(repo_path=self.repo_path, autoinit=False)
     commands.add(self.ui, self.repo)
     commands.forget(self.ui, self.repo,
                     os.path.join(self.repo_path,
                                  app.config['CONTENT_DIR']))
     commands.commit(self.ui, self.repo, message='foo', user='foo')
     app.blohg.init_repo(REVISION_DEFAULT)
     client = app.test_client()
     rv = client.get('/')
     self.assertFalse('post/lorem-ipsum' in rv.data)
     self.assertFalse('post/example-post' in rv.data)
     commands.add(self.ui, self.repo)
     rv = client.get('/')
     self.assertFalse('post/lorem-ipsum' in rv.data)
     self.assertFalse('post/example-post' in rv.data)
     commands.commit(self.ui, self.repo, message='foo', user='foo')
     rv = client.get('/')
     self.assertTrue('post/lorem-ipsum' in rv.data)
     self.assertTrue('post/example-post' in rv.data)
     with codecs.open(os.path.join(self.repo_path,
                                   app.config['CONTENT_DIR'],
                                   'about.rst'),
                      'a', encoding='utf-8') as fp:
         fp.write('\n\nTHIS IS A TEST!\n')
     rv = client.get('/about/')
     self.assertFalse('THIS IS A TEST!' in rv.data)
     commands.commit(self.ui, self.repo, message='foo', user='foo')
     rv = client.get('/about/')
     self.assertTrue('THIS IS A TEST!' in rv.data)
     with codecs.open(os.path.join(self.repo_path,
                                   app.config['CONTENT_DIR'],
                                   'about.rst'),
                      'a', encoding='utf-8') as fp:
         fp.write('\n\nTHIS IS another TEST!\n')
     rv = client.get('/about/')
     self.assertTrue('THIS IS A TEST!' in rv.data)
     self.assertFalse('THIS IS another TEST!' in rv.data)
     commands.commit(self.ui, self.repo, message='foo', user='foo')
     rv = client.get('/about/')
     self.assertTrue('THIS IS A TEST!' in rv.data)
     self.assertTrue('THIS IS another TEST!' in rv.data)

def repo_init(proj):
    """Init a new mercurial repository for ``proj``."""
    repo_path = os.path.join(G.REPOSITORY, proj)
    try:
        repo = repo_get(proj)
    except SPAMRepoNotFound:
        commands.init(repo_ui, repo_path)
        repo = repo_get(proj)
    
    hgignore_path = os.path.join(G.REPOSITORY, proj, '.hgignore')
    if not os.path.exists(hgignore_path):
        hgignore = open(hgignore_path, 'w')
        hgignore.write('syntax: regexp\n')
        hgignore.write('^.previews/')
        hgignore.close()
    
    if not '.hgignore' in repo['tip']:
        commands.add(repo_ui, repo, hgignore_path)
        matched = match.exact(repo.root, repo.getcwd(), ['.hgignore'])
        commit_id = repo.commit('add .hgignore', user='system', match=matched)

 def add_file(self, path):
     if self.vcs_type == 'git':
         # git wants a relative path
         path = path[len(self.path) + 1:]
         self.r.stage(path.encode('utf-8'))
     # FIXME: does not work if there was an
         # issue with other uncommitted things
         self.r.do_commit(
             message='commit {0}'.format(path.encode('utf-8')))
     elif self.vcs_type == 'hg':
         #_lock = self.r.lock()
         print '=' * 35
         print self.r.root
         print path
         print '=' * 35
         hg.add(self.ui, self.r, path.encode('utf-8'))
         hg.commit(
             self.ui,
             self.r,
             path.encode('utf-8'),
             message='commit {0}'.format(path))

    def writeIgnoreFile(self):
        eol = self.doseoln and '\r\n' or '\n'
        out = eol.join(self.ignorelines) + eol
        hasignore = os.path.exists(self.repo.join(self.ignorefile))

        try:
            f = util.atomictempfile(self.ignorefile, 'wb', createmode=None)
            f.write(out)
            f.close()
            if not hasignore:
                ret = qtlib.QuestionMsgBox(_('New file created'),
                                           _('TortoiseHg has created a new '
                                             '.hgignore file.  Would you like to '
                                             'add this file to the source code '
                                             'control repository?'), parent=self)
                if ret:
                    commands.add(ui.ui(), self.repo, self.ignorefile)
            shlib.shell_notify([self.ignorefile])
            self.ignoreFilterUpdated.emit()
        except EnvironmentError, e:
            qtlib.WarningMsgBox(_('Unable to write .hgignore file'),
                                hglib.tounicode(str(e)), parent=self)

	def openRepo(self):
		# Create a new repository or continue from aborted dump
		self.ui=ui.ui()
		self.last_names = {} # Tracks page renames: name atm -> last name in repo
		self.last_parents = {} # Tracks page parent names: name atm -> last parent in repo
		
		if os.path.isfile(self.path+'\\.wstate'):
			print "Continuing from aborted dump state..."
			self.loadState()
			self.repo = hg.repository(self.ui, self.path)
		
		else: # create a new repository (will fail if one exists)
			print "Initializing repository..."
			commands.init(self.ui, self.path)
			self.repo = hg.repository(self.ui, self.path)
			self.rev_no = 0
			
			if self.storeRevIds:
				# Add revision id file to the new repo
				fname = self.path+'\\.revid'
				codecs.open(fname, "w", "UTF-8").close()
				commands.add(self.ui, self.repo, str(fname))

    def commit(self, key, data):
        """
        commit changed ``data`` to the entity identified by ``key``.

        """

        try:
            fobj = open(os.path.join(self.location, key), 'w')
        except IOError:
            #parent directory seems to be missing
            os.makedirs(os.path.dirname(os.path.join(self.location, key)))
            return self.commit(key, data)
        fobj.write(data)
        fobj.close()
        
        u = self.hg_ui
        repo = hg.repository(u, self.location)
        try:
            commands.add(u, repo, os.path.join(self.location, key))
        except:
            raise
        commands.commit(u, repo, message='auto commit from django')

    def commit_revision(self, repo, raw_files, msg='no comment'):
        # DCI: Assert working dir is tip?
        manifest = repo['tip'].manifest()
        for fname, raw_bytes in raw_files:
            full_path = os.path.join(repo.root, fname)
            dname = os.path.dirname(full_path)
            if dname and not os.path.exists(dname):
                print "CREATED: ", dname
                os.makedirs(dname)

            out_file = open(full_path, 'wb')
            try:
                out_file.write(raw_bytes)
            finally:
                out_file.close()
            if not fname in manifest:
                commands.add(self.ui_, repo, full_path)

        commands.commit(self.ui_, repo,
                        logfile=None, addremove=None, user=None,
                        date=None,
                        message=msg)

    def addPath(self,
                path,
                rules=[]):
        try:
            if not opath.exists(path):
                error("Path",path,"does not exist")
        except TypeError:
            error(path,"is not a path name")

        include=[]
        exclude=[]
        if rules!=[]:
            for inclQ,patt in rules:
                if inclQ:
                    include.append("re:"+patt)
                else:
                    exclude.append("re:"+patt)

        commands.add(self.ui,
                     self.repo,
                     path,
                     include=include,
                     exclude=exclude)

def add(parent, ui, repo, files):
    if 'largefiles' in repo.extensions():
        result = lfprompt.promptForLfiles(parent, ui, repo, files)
        if not result:
            return False
        files, lfiles = result
        if files:
            commands.add(ui, repo, normal=True, *files)
        if lfiles:
            commands.add(ui, repo, lfsize='', normal=False, large=True, *lfiles)
    else:
        commands.add(ui, repo, *files)
    return True