Load gitignore file

jupyterlab_git/git.py

@@ -1681,6 +1681,22 @@ async def remote_remove(self, path, name):
 
         return response
 
+    async def read_file(self, path):
+        """
+        Reads file content located at path and returns it as a string
+
+        path: str
+            The path of the file
+        """
+        try:
+            file = pathlib.Path(path)
+            if file.stat().st_size > 0:
+                content = file.read_text()
+                return content
+            return ""
+        except BaseException as error:
+            return ""
+
     async def ensure_gitignore(self, path):
         """Handle call to ensure .gitignore file exists and the
         next append will be on a new line (this means an empty file
@@ -1721,6 +1737,32 @@ async def ignore(self, path, file_path):
             return {"code": -1, "message": str(error)}
         return {"code": 0}
 
+    async def writeGitignore(self, path, content):
+        """
+        Handle call to overwrite .gitignore.
+        Takes the .gitignore file and clears its previous contents
+        Writes the new content onto the file
+
+        path: str
+            Top Git repository path
+        content: str
+            New file contents
+        """
+        try:
+            res = await self.ensure_gitignore(path)
+            if res["code"] != 0:
+                return res
+            gitignore = pathlib.Path(path) / ".gitignore"
+            with gitignore.open("a") as f:
+                f.truncate(0)
+                f.seek(0)
+                f.write(content)
+                if content[-1] != "\n":
+                    f.write("\n")
+        except BaseException as error:
+            return {"code": -1, "message": str(error)}
+        return {"code": 0}
+
     async def version(self):
         """Return the Git command version.
 

jupyterlab_git/handlers.py

@@ -818,15 +818,21 @@ async def post(self, path: str = ""):
         local_path = self.url2localpath(path)
         data = self.get_json_body()
         file_path = data.get("file_path", None)
+        content = data.get("content", None)
         use_extension = data.get("use_extension", False)
-        if file_path:
+        if content:
+            body = await self.git.writeGitignore(local_path, content)
+        elif file_path:
             if use_extension:
                 suffixes = Path(file_path).suffixes
                 if len(suffixes) > 0:
                     file_path = "**/*" + ".".join(suffixes)
             body = await self.git.ignore(local_path, file_path)
         else:
             body = await self.git.ensure_gitignore(local_path)
+        if not self.serverapp.contents_manager.allow_hidden and not content:
+            self.set_status(403, "hidden files cannot be accessed")
+            body["content"] = await self.git.read_file(local_path + "/.gitignore")
 
         if body["code"] != 0:
             self.set_status(500)

src/commandsAndMenu.tsx

@@ -15,7 +15,7 @@ import { Contents, ContentsManager } from '@jupyterlab/services';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { ITerminal } from '@jupyterlab/terminal';
 import { ITranslator, TranslationBundle } from '@jupyterlab/translation';
-import { closeIcon, ContextMenuSvg } from '@jupyterlab/ui-components';
+import { closeIcon, ContextMenuSvg, saveIcon } from '@jupyterlab/ui-components';
 import { ArrayExt, find, toArray } from '@lumino/algorithm';
 import { CommandRegistry } from '@lumino/commands';
 import { PromiseDelegate } from '@lumino/coreutils';
@@ -52,6 +52,9 @@ import { AdvancedPushForm } from './widgets/AdvancedPushForm';
 import { GitCredentialsForm } from './widgets/CredentialsBox';
 import { discardAllChanges } from './widgets/discardAllChanges';
 import { CheckboxForm } from './widgets/GitResetToRemoteForm';
+import { CodeEditor } from '@jupyterlab/codeeditor/lib/editor';
+import { CodeEditorWrapper } from '@jupyterlab/codeeditor/lib/widget';
+import { editorServices } from '@jupyterlab/codemirror';
 
 export interface IGitCloneArgs {
   /**
@@ -303,13 +306,124 @@ export function addCommands(
     }
   });
 
+  async function showGitignore(error: any) {
+    const model = new CodeEditor.Model({});
+    const id = 'git-ignore';
+    //
+    const gitIgnoreWidget = find(shell.widgets(), shellWidget => {
+      if (shellWidget.id === id) {
+        return true;
+      }
+    });
+    if (gitIgnoreWidget) {
+      shell.activateById(id);
+      return;
+    }
+    model.sharedModel.setSource(error.content ? error.content : '');
+    const editor = new CodeEditorWrapper({
+      factory: editorServices.factoryService.newDocumentEditor,
+      model: model
+    });
+    const modelChangedSignal = model.sharedModel.changed;
+    editor.disposed.connect(() => {
+      model.dispose();
+    });
+    const preview = new PreviewMainAreaWidget({
+      content: editor
+    });
+    preview.title.label = '.gitignore';
+    preview.id = id;
+    preview.title.icon = gitIcon;
+    preview.title.closable = true;
+    const saveButton = new ToolbarButton({
+      icon: saveIcon,
+      onClick: async () => {
+        if (saved) {
+          return;
+        }
+        const newContent = model.sharedModel.getSource();
+        try {
+          await gitModel.writeGitIgnore(newContent);
+          preview.title.className = '';
+          saved = true;
+        } catch (error) {
+          console.log('Could not save .gitignore');
+        }
+      },
+      tooltip: trans.__('Saves .gitignore')
+    });
+    let saved = true;
+    preview.toolbar.addItem('save', saveButton);
+    shell.add(preview);
+    modelChangedSignal.connect(() => {
+      if (saved) {
+        saved = false;
+        preview.title.className = 'not-saved';
+      }
+    });
+  }
+
+  /* Helper: Show gitignore hidden file */
+  async function showGitignoreHiddenFile(error: any) {
+    const result = await showDialog({
+      title: trans.__('Warning: The .gitignore file is a hidden file.'),
+      body: (
+        <div>
+          {trans.__(
+            'Hidden files by default cannot be accessed with the regular code editor. In order to open the .gitignore file you must:'
+          )}
+          <ol>
+            <li>
+              {trans.__(
+                'Print the command below to create a jupyter_server_config.py file with defaults commented out. If you already have the file located in .jupyter, skip this step.'
+              )}
+              <div style={{ padding: '0.5rem' }}>
+                {trans.__('jupyter server --generate-config')}
+              </div>
+            </li>
+            <li>
+              {trans.__(
+                'Open jupyter_server_config.py, uncomment out the following line and set it to True:'
+              )}
+              <div style={{ padding: '0.5rem' }}>
+                {trans.__('c.ContentsManager.allow_hidden = False')}
+              </div>
+            </li>
+          </ol>
+        </div>
+      ),
+      buttons: [
+        Dialog.cancelButton({ label: trans.__('Cancel') }),
+        Dialog.okButton({ label: trans.__('Show .gitignore file anyways') })
+      ],
+      checkbox: {
+        label: 'Do not show this warning again',
+        checked: false
+      }
+    });
+    if (result.button.accept) {
+      settings.set('hideHiddenFileWarning', result.isChecked);
+      showGitignore(error);
+    }
+  }
+
   /** Add git open gitignore command */
   commands.addCommand(CommandIDs.gitOpenGitignore, {
     label: trans.__('Open .gitignore'),
     caption: trans.__('Open .gitignore'),
     isEnabled: () => gitModel.pathRepository !== null,
     execute: async () => {
-      await gitModel.ensureGitignore();
+      try {
+        await gitModel.ensureGitignore();
+      } catch (error: any) {
+        if (error?.name === 'hiddenFile') {
+          if (settings.composite['hideHiddenFileWarning']) {
+            await showGitignore(error);
+          } else {
+            await showGitignoreHiddenFile(error);
+          }
+        }
+      }
     }
   });
 
@@ -1456,7 +1570,13 @@ export function addCommands(
       const { files } = args as any as CommandArguments.IGitContextAction;
       for (const file of files) {
         if (file) {
-          await gitModel.ignore(file.to, false);
+          try {
+            await gitModel.ignore(file.to, false);
+          } catch (error: any) {
+            if (error?.name === 'hiddenFile') {
+              await showGitignoreHiddenFile(error);
+            }
+          }
         }
       }
     }

src/git.ts

@@ -65,6 +65,9 @@ export async function requestAPI<T>(
   if (!response.ok) {
     if (isJSON) {
       const { message, traceback, ...json } = data;
+      if (response.status === 403) {
+        throw new Git.HiddenFile(data.content);
+      }
       throw new Git.GitResponseError(
         response,
         message ||

src/model.ts

@@ -860,6 +860,7 @@ export class GitExtension implements IGitExtension {
    * @throws {Git.NotInRepository} If the current path is not a Git repository
    * @throws {Git.GitResponseError} If the server response is not ok
    * @throws {ServerConnection.NetworkError} If the request cannot be made
+   * @throws {Git.HiddenFile} If the file is hidden
    */
   async ensureGitignore(): Promise<void> {
     const path = await this._getPathRepository();
@@ -869,6 +870,20 @@ export class GitExtension implements IGitExtension {
     await this.refreshStatus();
   }
 
+  /**
+   * Overwrites content onto .gitignore file
+   *
+   * @throws {Git.NotInRepository} If the current path is not a Git repository
+   * @throws {Git.GitResponseError} If the server response is not ok
+   * @throws {ServerConnection.NetworkError} If the request cannot be made
+   */
+  async writeGitIgnore(content: string): Promise<void> {
+    const path = await this._getPathRepository();
+
+    await requestAPI(URLExt.join(path, 'ignore'), 'POST', { content: content });
+    await this.refreshStatus();
+  }
+
   /**
    * Fetch to get ahead/behind status
    *
@@ -923,6 +938,7 @@ export class GitExtension implements IGitExtension {
    * @throws {Git.NotInRepository} If the current path is not a Git repository
    * @throws {Git.GitResponseError} If the server response is not ok
    * @throws {ServerConnection.NetworkError} If the request cannot be made
+   * @throws {Git.HiddenFile} If hidden files are not enabled
    */
   async ignore(filePath: string, useExtension: boolean): Promise<void> {
     const path = await this._getPathRepository();

src/tokens.ts

@@ -1300,6 +1300,16 @@ export namespace Git {
     }
   }
 
+  export class HiddenFile extends Error {
+    content: string;
+    constructor(content: string) {
+      super('File is hidden');
+      this.name = 'hiddenFile';
+      this.message = 'File is hidden and cannot be accessed.';
+      this.content = content;
+    }
+  }
+
   /**
    * Interface for dialog with one checkbox.
    */

style/diff-common.css

@@ -180,3 +180,17 @@ button.jp-git-diff-resolve .jp-ToolbarButtonComponent-label {
     var(--jp-border-color0) 12px
   );
 }
+
+.not-saved
+  > .lm-TabBar-tabCloseIcon
+  > :not(:hover)
+  > .jp-icon-busy[fill] {
+  fill: var(--jp-inverse-layout-color3);
+}
+
+.not-saved
+  > .lm-TabBar-tabCloseIcon
+  > :not(:hover)
+  > .jp-icon3[fill] {
+  fill: none;
+}