Use VCS agnostic method names

We already support Git and Mercurial and this naming can be confusing.

Signed-off-by: Michal Čihař <michal@cihar.com>

weblate/html/js/git-status.html

@@ -1,6 +1,6 @@
 {% load i18n %}
 {% load translations %}
-{% with object.git_needs_commit as needs_commit %}
+{% with object.repo_needs_commit as needs_commit %}
 
 <div class="row">
 <div class="col-md-8">
@@ -18,13 +18,13 @@
 <p><a href="{% documentation "faq" "merge" %}">{% trans "Check our FAQ for information how to resolve this." %}</a></p>
 </div>
 {% else %}
-{% if object.git_needs_merge %}
+{% if object.repo_needs_merge %}
 <div class="alert alert-warning" role="alert">{% trans "The remote repository needs to be merged!" %}</div>
 {% endif %}
-{% if object.git_needs_push %}
+{% if object.repo_needs_push %}
 <div class="alert alert-warning" role="alert">{% trans "There are some new commits in the local repository!" %}</div>
 {% endif %}
-{% if not needs_commit and not object.git_needs_merge and not object.git_needs_push %}
+{% if not needs_commit and not object.repo_needs_merge and not object.repo_needs_push %}
 <div class="alert alert-success" role="alert">{% trans "The local repository is up to date." %}</div>
 {% endif %}
 {% endif %}

weblate/trans/management/commands/commit_pending.py

@@ -42,7 +42,7 @@ def handle(self, *args, **options):
         age = timezone.now() - timedelta(hours=options['age'])
 
         for translation in self.get_translations(*args, **options):
-            if not translation.git_needs_commit():
+            if not translation.repo_needs_commit():
                 continue
 
             last_change = translation.last_change

weblate/trans/models/project.py

@@ -343,24 +343,24 @@ def get_language_count(self):
         """
         return self.get_languages().count()
 
-    def git_needs_commit(self):
+    def repo_needs_commit(self):
         """
         Checks whether there are some not committed changes.
         """
         for component in self.subproject_set.all():
-            if component.git_needs_commit():
+            if component.repo_needs_commit():
                 return True
         return False
 
-    def git_needs_merge(self):
+    def repo_needs_merge(self):
         for component in self.subproject_set.all():
-            if component.git_needs_merge():
+            if component.repo_needs_merge():
                 return True
         return False
 
-    def git_needs_push(self):
+    def repo_needs_push(self):
         for component in self.subproject_set.all():
-            if component.git_needs_push():
+            if component.repo_needs_push():
                 return True
         return False
 

weblate/trans/models/subproject.py

@@ -651,7 +651,7 @@ def do_update(self, request=None, method=None):
         self.update_remote_branch()
 
         # do we have something to merge?
-        if not self.git_needs_merge() and method != 'rebase':
+        if not self.repo_needs_merge() and method != 'rebase':
             return True
 
         # commit possible pending changes
@@ -667,7 +667,7 @@ def do_update(self, request=None, method=None):
         self.create_translations(request=request)
 
         # Push after possible merge
-        if (self.git_needs_push() and
+        if (self.repo_needs_push() and
                 ret and
                 self.project.push_on_commit and
                 self.can_push()):
@@ -696,15 +696,15 @@ def do_push(self, request, force_commit=True, do_update=True):
             self.commit_pending(request, skip_push=True)
 
         # Do we have anything to push?
-        if not self.git_needs_push():
+        if not self.repo_needs_push():
             return False
 
         if do_update:
             # Update the repo
             self.do_update(request)
 
             # Were all changes merged?
-            if self.git_needs_merge():
+            if self.repo_needs_merge():
                 return False
 
         # Do actual push
@@ -1282,28 +1282,28 @@ def _get_percents(self):
         '''
         return self.translation_set.get_percents()
 
-    def git_needs_commit(self):
+    def repo_needs_commit(self):
         '''
         Checks whether there are some not committed changes.
         '''
         if self.is_repo_link:
-            return self.linked_subproject.git_needs_commit()
+            return self.linked_subproject.repo_needs_commit()
         return self.repository.needs_commit()
 
-    def git_needs_merge(self):
+    def repo_needs_merge(self):
         '''
         Checks whether there is something to merge from remote repository.
         '''
         if self.is_repo_link:
-            return self.linked_subproject.git_needs_merge()
+            return self.linked_subproject.repo_needs_merge()
         return self.repository.needs_merge(self.branch)
 
-    def git_needs_push(self):
+    def repo_needs_push(self):
         '''
         Checks whether there is something to push to remote repository.
         '''
         if self.is_repo_link:
-            return self.linked_subproject.git_needs_push()
+            return self.linked_subproject.repo_needs_push()
         return self.repository.needs_push(self.branch)
 
     @property

weblate/trans/models/translation.py

@@ -777,17 +777,17 @@ def __git_commit(self, author, timestamp, sync=False):
         if sync:
             self.store_hash()
 
-    def git_needs_commit(self):
+    def repo_needs_commit(self):
         '''
         Checks whether there are some not committed changes.
         '''
         return self.repository.needs_commit(self.filename)
 
-    def git_needs_merge(self):
-        return self.subproject.git_needs_merge()
+    def repo_needs_merge(self):
+        return self.subproject.repo_needs_merge()
 
-    def git_needs_push(self):
-        return self.subproject.git_needs_push()
+    def repo_needs_push(self):
+        return self.subproject.repo_needs_push()
 
     def git_commit(self, request, author, timestamp, force_commit=False,
                    sync=False, skip_push=False):
@@ -800,7 +800,7 @@ def git_commit(self, request, author, timestamp, force_commit=False,
         translation rescan will be needed)
         '''
         # Is there something for commit?
-        if not self.git_needs_commit():
+        if not self.repo_needs_commit():
             return False
 
         # Can we delay commit?

weblate/trans/tests/test_views.py

@@ -608,25 +608,25 @@ def test_commit_push(self):
         )
         # We should get to second message
         self.assertRedirectsOffset(response, self.translate_url, 1)
-        self.assertTrue(self.translation.git_needs_commit())
-        self.assertTrue(self.subproject.git_needs_commit())
-        self.assertTrue(self.subproject.project.git_needs_commit())
+        self.assertTrue(self.translation.repo_needs_commit())
+        self.assertTrue(self.subproject.repo_needs_commit())
+        self.assertTrue(self.subproject.project.repo_needs_commit())
 
         self.translation.commit_pending(self.get_request('/'))
 
-        self.assertFalse(self.translation.git_needs_commit())
-        self.assertFalse(self.subproject.git_needs_commit())
-        self.assertFalse(self.subproject.project.git_needs_commit())
+        self.assertFalse(self.translation.repo_needs_commit())
+        self.assertFalse(self.subproject.repo_needs_commit())
+        self.assertFalse(self.subproject.project.repo_needs_commit())
 
-        self.assertTrue(self.translation.git_needs_push())
-        self.assertTrue(self.subproject.git_needs_push())
-        self.assertTrue(self.subproject.project.git_needs_push())
+        self.assertTrue(self.translation.repo_needs_push())
+        self.assertTrue(self.subproject.repo_needs_push())
+        self.assertTrue(self.subproject.project.repo_needs_push())
 
         self.translation.do_push(self.get_request('/'))
 
-        self.assertFalse(self.translation.git_needs_push())
-        self.assertFalse(self.subproject.git_needs_push())
-        self.assertFalse(self.subproject.project.git_needs_push())
+        self.assertFalse(self.translation.repo_needs_push())
+        self.assertFalse(self.subproject.repo_needs_push())
+        self.assertFalse(self.subproject.project.repo_needs_push())
 
     def test_auto(self):
         '''