Try (#15)

* stage/unstage hunk
* select multiple files to stage/unstage
* performance improvements
* add new keybindings, 'space' to stage/unstage, 'backspace' to discard changes

Author: predragnikolic

README.md

@@ -2,33 +2,35 @@
 
 Get a quick overview of changes before committing them.
 
-![Example](img/showcase.png)
-
 ### Features
 
--   Show all modified files
--   Show the diff view for a file
--   Stage/Unstage files
--   Discard changes to a file
+-   Show modified files (AKA "Status View")
+-   View diff for a file. (AKA "Diff View")
+-   Stage/Unstage files/hunks
+-   Discard changes to files/hunks
 -   Goto a file
 
-### Installation 
+![Example](img/showcase.png)
+
+### Getting Started
 
 Open the command palette and run `Package Control: Install Package`, then select `GitDiffView`.
 
-### Instructions
-
-From the command palette select: `Git Diff View: Toggle`.
-Or toggle the git diff view with `ctrl+shift+g`(Linux) or `alt+shift+g`(Mac).
+Toggle the git diff view with `ctrl+shift+g`(Linux) or `alt+shift+g`(Mac) or via the command palette by selecting: `Git Diff View: Toggle`.
 The git diff view won't open if there are no git changes.
 
-Inside the status view, the following keybindings are available:
 
-```
-  a - stage/unstage a file
-  d - dismiss changes to a file
-  g - go to a file
-```
+### Keybindings in Status View (the right view)
+
+- <kbd>a</kbd> / <kbd>space</kbd> - stage/unstage file
+- <kbd>d</kbd> / <kbd>backspace</kbd> - dismiss file changes
+- <kbd>g</kbd> - open file
+
+
+### Keybindings in Diff View (the left view)
+
+- <kbd>a</kbd> / <kbd>space</kbd> - stage/unstage hunk
+- <kbd>d</kbd> / <kbd>backspace</kbd> - dismiss hunk change
 
 Type of modification will be shown in the git status, next to the file name.
 Here is a list of the types:

command_clear_diff_view.py

@@ -1,3 +1,4 @@
+from .command_update_diff_view import update_diff_view
 from .core.git_commands import Git
 from .core.git_diff_view import GitDiffView
 from .utils import get_line
@@ -20,12 +21,12 @@ def run(self, _: sublime.Edit) -> None:
         if not git_status:
             return
 
-        def done(option):
+        def done(option: int) -> None:
             if option == -1:
                 return
             # 0 -> Discard changes
             if git_status["is_staged"]:
-                git.reset_head(git_status["file_name"])
+                git.unstage_files([git_status["file_name"]])
             if git_status["modification_type"] == '??':
                 git.clean(git_status["file_name"])
             else:
@@ -34,10 +35,13 @@ def done(option):
             self.view.run_command('update_status_view', {
                 'git_statuses': git_statuses,
             })
-            self.view.run_command("update_diff_view", {
-                'git_status': git_status,
-            })
+            try:
+                new_git_status = git_statuses[line]
+                update_diff_view(self.view, new_git_status)
+            except:
+                update_diff_view(self.view, None)
 
         self.view.show_popup_menu([
             'Confirm Discard'
         ], done)
+        window.focus_view(self.view)

command_dismiss_changesd.py command_dismiss_changes.pycommand_dismiss_changesd.py renamed to command_dismiss_changes.py

@@ -0,0 +1,77 @@
+import os
+
+from .command_update_diff_view import update_diff_view
+from .core.status_view import get_status_view
+from .core.git_commands import Git
+from .core.git_diff_view import GitDiffView
+from .utils import get_line
+import sublime
+import sublime_plugin
+
+
+# command: git_diff_view_dismiss_hunk_changes
+class GitDiffViewDismissHunkChangesCommand(sublime_plugin.TextCommand):
+    def run(self, _: sublime.Edit) -> None:
+        def done(option: int) -> None:
+            if option == -1:
+                return
+            window = self.view.window()
+            if not window:
+                return
+            diff_view = self.view
+            sel = diff_view.sel()
+            if not sel:
+                return
+            cursor = sel[0].b
+            status_view = get_status_view(window.views())
+            if not status_view:
+                return
+            line = get_line(status_view)
+            if line is None:
+                return
+            git = Git(window)
+            git_statuses = GitDiffView.git_statuses[window.id()]
+            git_status = git_statuses[line]
+            if not git_status:
+                return
+            head = git.diff_head(git_status['file_name'])
+
+            start_patch = diff_view.find('^@@', cursor, sublime.REVERSE)
+            if not start_patch:
+                return
+
+            end_patch = diff_view.find('^@@', cursor)
+            if not end_patch:
+                end_patch = sublime.Region(diff_view.size())
+            hunk_content = diff_view.substr(sublime.Region(start_patch.begin(), end_patch.begin()))
+            patch_content = f"{head}\n{hunk_content}"
+
+            not_staged = not git_status['is_staged'] or diff_view.find('^Unstaged', cursor, sublime.REVERSE)
+            temp_patch_file = os.path.join(sublime.cache_path(), 'temp_patch_file.patch')
+            patch_file = open(temp_patch_file, 'w', encoding='utf-8')
+            try:
+                patch_file.write(patch_content)
+                patch_file.close()
+                if not_staged:
+                    git.discard_patch(temp_patch_file)
+                else:
+                    # for staged files first unstage patch
+                    git.unstage_patch(temp_patch_file)
+                    git.discard_patch(temp_patch_file)
+            finally:
+                patch_file.close()
+                os.remove(patch_file.name)
+
+            new_git_statuses = git.git_statuses()
+            status_view.run_command('update_status_view', {
+                'git_statuses': new_git_statuses,
+            })
+            try:
+                new_git_status = new_git_statuses[line]
+                update_diff_view(self.view, new_git_status)
+            except:
+                update_diff_view(self.view, None)
+
+        self.view.show_popup_menu([
+            'Discard Hunk'
+        ], done)

command_dismiss_hunk.py

@@ -30,4 +30,9 @@ def run(self, _: sublime.Edit) -> None:
                                           git_status["file_name"])
         window.run_command('toggle_git_diff_view')
         view = window.open_file(absolute_path_to_file)
-        sublime.set_timeout(lambda: window.focus_view(view))
+
+        def deffer_focus_view() -> None:
+            if window:
+                window.focus_view(view)
+
+        sublime.set_timeout(deffer_focus_view)

command_goto_file.py

@@ -0,0 +1,52 @@
+from .core.status_view import get_status_view
+from .core.git_commands import Git
+from .core.git_diff_view import GitDiffView
+from .utils import get_line
+from os import path
+import sublime
+import sublime_plugin
+
+
+# command: git_diff_view_goto_file
+class GitDiffViewGotoHunkCommand(sublime_plugin.TextCommand):
+    def run(self, _: sublime.Edit) -> None:
+        diff_view = self.view
+        window = self.view.window()
+        if not window:
+            return
+        status_view = get_status_view(window.views())
+        if not status_view:
+            return
+        line = get_line(status_view)
+        if line is None:
+            return
+        git = Git(window)
+        git_statuses = GitDiffView.git_statuses[window.id()]
+        git_status = git_statuses[line]
+        if not git_status:
+            return
+        if 'D' in git_status["modification_type"]:
+            window.status_message("GitDiffVIew: Can't go to a deleted file")
+            return
+        file_name = git_status["file_name"]
+        if not git.git_root_dir or not file_name:
+            return
+        absolute_path_to_file = path.join(git.git_root_dir,
+                                          git_status["file_name"])
+        sel = diff_view.sel()
+        if not sel:
+            return
+        cursor = sel[0].b
+        start_patch = diff_view.find('^@@.+@@', cursor, sublime.REVERSE)
+        row = 0
+        if start_patch:
+            header = diff_view.substr(start_patch).split(' ')  #  ['@@', '-23,5', '+23,10', '@@']
+            row = int(header[2].replace('-', '').replace('+', '').split(',')[0])  # row = 23
+        window.run_command('toggle_git_diff_view')
+
+        def deffer_goto_file():
+            if window.is_valid():
+                view = window.open_file(f"{absolute_path_to_file}:{row}", sublime.ENCODED_POSITION)
+                window.focus_view(view)
+
+        sublime.set_timeout(deffer_goto_file, 50)

command_goto_hunk.py

@@ -1,16 +1,17 @@
 import sublime
 from .core.git_commands import Git
 from .core.git_diff_view import GitDiffView
-from .utils import get_line
+from .utils import get_selected_lines, get_line
 import sublime_plugin
-
+from .command_update_diff_view import update_diff_view
 
 # command: git_diff_view_stage_unstage
 class GitDiffViewStageUnstageCommand(sublime_plugin.TextCommand):
     def run(self, _: sublime.Edit) -> None:
         window = self.view.window()
         if not window:
             return
+        selected_lines = get_selected_lines(self.view)
         line = get_line(self.view)
         if line is None:
             return
@@ -19,14 +20,14 @@ def run(self, _: sublime.Edit) -> None:
         git_status = git_statuses[line]
         if not git_status:
             return
+
+        file_names = [git_statuses[line]['file_name'] for line in selected_lines]
         if git_status["is_staged"]:
-            git.reset_head(git_status["file_name"])
+            git.unstage_files(file_names)
         else:
-            git.add(git_status["file_name"])
+            git.stage_files(file_names)
         git_statuses = git.git_statuses()
         self.view.run_command('update_status_view', {
             'git_statuses': git_statuses,
         })
-        self.view.run_command("update_diff_view", {
-            'git_status': git_status,
-        })
+        update_diff_view(self.view, git_status)

command_stage_unstage_file.py

@@ -0,0 +1,64 @@
+from .command_update_diff_view import update_diff_view
+import sublime
+from .core.git_commands import Git
+from .core.status_view import get_status_view
+from .core.git_diff_view import GitDiffView
+from .utils import get_line
+import sublime_plugin
+import os
+
+
+# command: git_diff_view_stage_unstage_hunk
+class GitDiffViewStageUnstageHunkCommand(sublime_plugin.TextCommand):
+    def run(self, _: sublime.Edit) -> None:
+        window = self.view.window()
+        if not window:
+            return
+        diff_view = self.view
+        sel = diff_view.sel()
+        if not sel:
+            return
+        cursor = sel[0].b
+        status_view = get_status_view(window.views())
+        if not status_view:
+            return
+        line = get_line(status_view)
+        if line is None:
+            return
+        git = Git(window)
+        git_statuses = GitDiffView.git_statuses[window.id()]
+        git_status = git_statuses[line]
+        if not git_status:
+            return
+        head = git.diff_head(git_status['file_name'])
+
+        start_patch = diff_view.find('^@@', cursor, sublime.REVERSE)
+        if not start_patch:
+            return
+
+        end_patch = diff_view.find('^@@', cursor)
+        if not end_patch:
+            end_patch = sublime.Region(diff_view.size())
+        hunk_content = diff_view.substr(sublime.Region(start_patch.begin(), end_patch.begin()))
+        patch_content = f"{head}\n{hunk_content}"
+
+        not_staged = not git_status['is_staged'] or diff_view.find('^Unstaged', cursor, sublime.REVERSE)
+        temp_patch_file = os.path.join(sublime.cache_path(), 'temp_patch_file.patch')
+        patch_file = open(temp_patch_file, 'w', encoding='utf-8')
+        try:
+            patch_file.write(patch_content)
+            patch_file.close()
+            if not_staged:
+                git.stage_patch(temp_patch_file)
+            else:
+                git.unstage_patch(temp_patch_file)
+        finally:
+            patch_file.close()
+            os.remove(patch_file.name)
+
+        new_git_statuses = git.git_statuses()
+        new_git_status = new_git_statuses[line]
+        status_view.run_command('update_status_view', {
+            'git_statuses': new_git_statuses,
+        })
+        update_diff_view(self.view, new_git_status)