Merge branch 'main' into bugfix/exportAll-better-handle-deleted-items

Author: cambot

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 - Expanded Baseline Export to include XSL Transforms (#815)
+- Enhanced "Check out branch" to first refresh list of remote branches to eliminate failure due to stale information (#823)
 
 ### Fixed
 - Fix Import All not importing items that do not already exist when compileOnImport is not set (#798)
@@ -17,6 +18,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fixed another instance of deletes showing as owned by undefined user (#812)
 - Fix Revert not syncing files with IRIS (#789)
 - Fix "Export All" stopping prematurely because a tracked item no longer exist in the namespace (#821)
+- Import All now outputs a warning instead of an error when an item is in the wrong path (#291)
+
 
 ## [2.12.2] - 2025-07-08
 

CONTRIBUTING.md

@@ -14,7 +14,7 @@ We encourage use of [Conventional Commits](https://www.conventionalcommits.org/e
 
 Generally speaking, just try to match the conventions you see in the code you are reading. For this project, these include:
 
-* Do not use shortened command and function names. For example, use `set` instead of `s` instead of `set` and `$piece` instead of `$p`
+* Do not use shortened command and function names. For example, use `set` instead of `s` and `$piece` instead of `$p`
 * One command per line
 * Do not use dot syntax
 * Indentation with tabs

cls/SourceControl/Git/Utils.cls

@@ -443,13 +443,14 @@ ClassMethod NewBranch(newBranchName As %String) As %Status
 
 ClassMethod SwitchBranch(targetBranchName As %String) As %Status
 {
-    // Make sure that branch exists first (-a lists both local and remote)
-    do ..RunGitWithArgs(.errStream,.outStream,"branch", "-a")
+    // First, make sure that branch exists
+    do ..RunGitCommand("fetch", .errStream, .outStream, "--prune")    // refresh list of remote branches
+    do ..RunGitWithArgs(.errStream, .outStream, "branch", "-a")       // -a lists both local and remote
     set branches = outStream.Read()
-    if ('$find(branches,targetBranchName)) {
+    if ('$FIND(branches, targetBranchName)) {
         quit $$$ERROR($$$GeneralError, "Selected branch does not exist"_$C(10))
     }
-    k outStream, errStream
+    kill outStream, errStream
     do ..RunGitWithArgs(.errStream, .outStream, "checkout", targetBranchName)
     do ..PrintStreams(errStream, outStream)
     // Checkout can fail due to unstaged changes
@@ -1536,7 +1537,7 @@ ClassMethod ListItemsInFiles(ByRef itemList, ByRef err) As %Status
     }
 
     if $get(err) > 0 {
-        write !, "There were some errors while importing files"
+        write !, "Warning: unrecognized files found in the sources directory:"
         for i=1:1:err {
             write !, err(i)
         }
@@ -2819,7 +2820,7 @@ ClassMethod GetSourceControlInclude(prefix As %String = {%request.URLPrefix}) As
 
 XData ProductionConfigScript [ MimeType = text/javascript ]
 {
-    function checkProductionConfigLoad() {
+function checkProductionConfigLoad() {
         timerState(false);
     }
 

docs/menu-items.md

@@ -1,8 +1,8 @@
 # git-source-control Menu Items
 
-
 ## Status
 This menu option is analogous to the [git status](https://git-scm.com/docs/git-status) command and prints the status of the repository to the output.
+
 ## Settings
 This option opens the GUI's settings page project specific git-source-control settings can be configured. This includes the settings that were configured when running:
 ```
@@ -12,31 +12,49 @@ d ##class(SourceControl.Git.API).Configure()
 This page also includes the mappings configurations.
 
 Any changes made to the settings must be saved using the 'Save' button in order to take effect.
+
 ## Launch Git UI
 This menu option opens the git-source-control GUI. From here commit messages can be written, files can be staged and committed, branches can be viewed.
+
 ## Add
 This menu option is analogous to the [git add](https://git-scm.com/docs/git-add) command. It will perform 'git add' on the currently open file, adding it to the files that can be staged.
+
 ## Remove
 This menu option will only appear if the currently open file has been already added using the 'Add' menu option. It undoes the effect of adding the file, similar to running [git reset](https://git-scm.com/docs/git-reset) on a specific file.
+
 ## Push to remote branch
 This option pushes the commits in the branch to the remote repository. This exhibits the same behavior as the [git push](https://git-scm.com/docs/git-push) command.
+
 ## Push to remote branch (force)
 This option forcibly pushes the commits in the branch to the remote repository. This is potentially destructive and may overwrite the commit history of the remote branch. This exhibits the same behavior as the [git push --force](https://git-scm.com/docs/git-push) command.
+
 ## Fetch from remote
-Much like the [git fetch](https://git-scm.com/docs/git-fetch) command, this option fetches the most recent versions of the branch without merging that version into the local copy of the branch.
+This option first [fetches](https://git-scm.com/docs/git-fetch) the most recent version of the branch without merging that version into the local copy of the branch.  It will then list all files modified between the current version and the remote version.
+
+This also has the effect of refreshing the list of all remote branches and pruning any references that no longer exist in the remote.  (see: [git fetch --prune](https://git-scm.com/docs/git-fetch#Documentation/git-fetch.txt---prune))
+
 ## Pull changes from remote branch
 Much like the [git pull](https://git-scm.com/docs/git-pull) command, this menu option pulls the most recent version of the current branch from a remote source, merging the changes into the local copy.
+
 ## Sync
 This option will synchronize a local repo with the remote repo. The sync operation is only enabled in basic mode. It encapsulates the pattern of fetching, pulling, committing and then pushing into one menu action. If there is no defined remote repository, it will simply commit any uncommitted files.
+
 ## Create new branch
 This menu option creates a new branch in the repository for changes to be committed to. It also changes the current branch to be the created branch. This mimics the behavior of the [git checkout -b](https://git-scm.com/docs/git-checkout) command.
+
 ## Check out an existing branch
-This option changes the currently checkout branch to a chosen branch. This mimics the behavior of the [git checkout](https://git-scm.com/docs/git-checkout) command.
+This option refreshes the local list of branches available in the upstream repository, and then changes the currently checkedout branch to the provided branch.  This mimics the behavior of the [git fetch --prune](https://git-scm.com/docs/git-fetch#Documentation/git-fetch.txt---prune) and [git checkout](https://git-scm.com/docs/git-checkout) commands.
+
+If the desired branch does not exist in your local or in the remote, then you will receive the "Selected branch does not exist" error message.
+
 ## Export all
 This option exports class files to the local file tree at the configured location.
+
 ## Export all (force)
 This option exports all class files regardless of whether they're already up to date in the local file tree or not.
+
 ## Import all
 This option imports the versions of the files that are found in the configured directory into the project. Files that are out of date or the same as the files in the project won't be imported.
+
 ## Import all (force)
-This menu option behaves similarly to the regular import but forces the files to be imported regardless of whether the on-disk version is the same or older. 
+This menu option behaves similarly to the regular import but forces the files to be imported regardless of whether the on-disk version is the same or older.

test/UnitTest/SourceControl/Git/AbstractTest.cls

@@ -0,0 +1,40 @@
+Class UnitTest.SourceControl.Git.AbstractTest Extends %UnitTest.TestCase
+{
+
+Property InitialExtension As %String [ InitialExpression = {##class(%Studio.SourceControl.Interface).SourceControlClassGet()} ];
+
+Property SourceControlGlobal [ MultiDimensional ];
+
+Method %OnNew(initvalue) As %Status
+{
+	Merge ..SourceControlGlobal = ^SYS("SourceControl")
+	Kill ^SYS("SourceControl")
+	Set settings = ##class(SourceControl.Git.Settings).%New()
+	Set settings.namespaceTemp = ##class(%Library.File).TempFilename()_"dir"
+	Set settings.Mappings("CLS","*")="cls/"
+	Do settings.%Save()
+	Do ##class(%Studio.SourceControl.Interface).SourceControlClassSet("SourceControl.Git.Extension")
+	Quit ##super(initvalue)
+}
+
+Method %OnClose() As %Status [ Private, ServerOnly = 1 ]
+{
+	Do ##class(%Studio.SourceControl.Interface).SourceControlClassSet(..InitialExtension)
+	Kill ^SYS("SourceControl")
+	Merge ^SYS("SourceControl") = ..SourceControlGlobal
+	Quit $$$OK
+}
+
+ClassMethod WriteFile(filePath, contents)
+{
+    set dirPath = ##class(%File).GetDirectory(filePath)
+    if '##class(%File).CreateDirectoryChain(dirPath,.ret) {
+        $$$ThrowStatus($$$ERROR($$$GeneralError,"failed to create directory: "_ret))
+    }
+    set fileStream = ##class(%Stream.FileCharacter).%OpenId(filePath,,.sc)
+    $$$ThrowOnError(sc)
+    do fileStream.Write(contents)
+    $$$ThrowOnError(fileStream.%Save())
+}
+
+}

test/UnitTest/SourceControl/Git/ImportAll.cls

@@ -0,0 +1,61 @@
+Class UnitTest.SourceControl.Git.ImportAll Extends %UnitTest.TestCase
+{
+
+Property InitialExtension As %String [ InitialExpression = {##class(%Studio.SourceControl.Interface).SourceControlClassGet()} ];
+
+Property SourceControlGlobal [ MultiDimensional ];
+
+Method %OnNew(initvalue) As %Status
+{
+	Merge ..SourceControlGlobal = ^SYS("SourceControl")
+	Kill ^SYS("SourceControl")
+	Set settings = ##class(SourceControl.Git.Settings).%New()
+	Set settings.namespaceTemp = ##class(%Library.File).TempFilename()_"dir"
+	Set settings.Mappings("MAC","*")="rtn/"
+	$$$ThrowOnError(settings.%Save())
+	Do ##class(%Studio.SourceControl.Interface).SourceControlClassSet("SourceControl.Git.Extension")
+	Quit ##super(initvalue)
+}
+
+Method %OnClose() As %Status [ Private, ServerOnly = 1 ]
+{
+	Do ##class(%Studio.SourceControl.Interface).SourceControlClassSet(..InitialExtension)
+	Kill ^SYS("SourceControl")
+	Merge ^SYS("SourceControl") = ..SourceControlGlobal
+	Quit $$$OK
+}
+
+Method TestImportAll()
+{
+	do ..CreateTestRoutine()
+	$$$ThrowOnError(##class(SourceControl.Git.Utils).AddToSourceControl("test.mac"))
+	do ..CreateStrayFileInRtn()
+	$$$ThrowOnError(##class(%Routine).Delete("test.mac"))
+	$$$ThrowOnError(##class(SourceControl.Git.Utils).ImportAll(1))
+	do $$$AssertTrue(##class(%Routine).Exists("test.mac"))
+}
+
+Method CreateTestRoutine()
+{
+	if '##class(%Routine).Exists("test.mac") {
+		set r = ##class(%Routine).%New("test.mac")
+		do r.WriteLine(" write 22,!")
+		do r.Save()
+		do r.Compile()
+	}
+}
+
+/// creates a text file in the routines directory that is not really a routine
+Method CreateStrayFileInRtn()
+{
+	set fileStream = ##class(%Stream.FileCharacter).%OpenId(
+			##class(%File).NormalizeFilename(
+				"test.txt",
+				##class(%File).GetDirectory(##class(SourceControl.Git.Utils).FullExternalName("test.mac")))
+			,,.sc)
+	$$$ThrowOnError(sc)
+	$$$ThrowOnError(fileStream.Write("hello world!"))
+	$$$ThrowOnError(fileStream.%Save())
+}
+
+}

test/UnitTest/SourceControl/Git/Pull.cls

@@ -0,0 +1,40 @@
+Class UnitTest.SourceControl.Git.Pull Extends UnitTest.SourceControl.Git.AbstractTest
+{
+
+Method TestPull()
+{
+    // initialize remote repository on filesystem
+    set remoteDir = ##class(%Library.File).TempFilename()_"d"
+    if '##class(%File).CreateDirectoryChain(remoteDir_"/cls",.ret) {
+        $$$ThrowStatus($$$ERROR($$$GeneralError,"failed to create directory: "_ret))
+    }
+    do ..WriteFile(remoteDir_"/cls/TestGit/SampleClass1.cls","Class TestGit.SampleClass1 {}")
+    do ..WriteFile(remoteDir_"/cls/TestGit/SampleClass2.cls","Class TestGit.SampleClass2 {}")
+    do $zf(-100,"/SHELL","git","init",remoteDir)
+    do $zf(-100,"/SHELL","git", "-C", remoteDir, "config", "user.email", "[email protected]")
+    do $zf(-100,"/SHELL","git", "-C", remoteDir, "config", "user.name", "Unit Test")
+    do $zf(-100,"/SHELL","git", "-C", remoteDir, "add", ".")
+    do $zf(-100,"/SHELL","git", "-C", remoteDir, "commit", "-m", "initial commit in remote for unit test")
+    // initialize local repo, cloning remote.
+    $$$ThrowOnError(##class(SourceControl.Git.Utils).Clone(remoteDir_"/.git"))
+    // import all and confirm classes exist
+    do $System.OBJ.Delete("TestGit.SampleClass1,TestGit.SampleClass2")
+    $$$ThrowOnError(##class(SourceControl.Git.Utils).ImportAll(1))
+    do $$$AssertTrue($$$comClassDefined("TestGit.SampleClass1"))
+    do $$$AssertTrue($$$comClassDefined("TestGit.SampleClass2"))
+    // delete, add, and modify classes on remote. add and commit them all on remote.
+    if '##class(%File).Delete(remoteDir_"/cls/TestGit/SampleClass1.cls",.ret) {
+        $$$ThrowStatus($$$ERROR($$$GeneralError,"failed to delete class file"))
+    }
+    do ..WriteFile(remoteDir_"/cls/TestGit/SampleClass2.cls","Class TestGit.SampleClass2 { Parameter foo = ""bar""; }")
+    do ..WriteFile(remoteDir_"/cls/TestGit/SampleClass3.cls","Class TestGit.SampleClass3 {}")
+    do $zf(-100,"/SHELL","git", "-C", remoteDir, "add", ".")
+    do $zf(-100,"/SHELL","git", "-C", remoteDir, "commit", "-m", "delete, modify, and add classes on remote")
+    // pull on local and confirm changes were loaded.
+    $$$ThrowOnError(##class(SourceControl.Git.API).Pull())
+    do $$$AssertNotTrue($$$comClassDefined("TestGit.SampleClass1"))
+    do $$$AssertEquals(##class(TestGit.SampleClass2).#foo, "bar")
+    do $$$AssertTrue($$$comClassDefined("TestGit.SampleClass3"))
+}
+
+}

test/UnitTest/SourceControl/Git/Sync.cls

@@ -0,0 +1,53 @@
+Class UnitTest.SourceControl.Git.Sync Extends UnitTest.SourceControl.Git.AbstractTest
+{
+
+Method TestSync()
+{
+    do $$$LogMessage("set up remote repo on filesystem")
+    set remoteDir = ##class(%Library.File).TempFilename()_"d"
+    if '##class(%File).CreateDirectoryChain(remoteDir,.ret) {
+        $$$ThrowStatus($$$ERROR($$$GeneralError,"failed to create directory: "_ret))
+    }
+    do $zf(-100,"/SHELL","git","init",remoteDir)
+    do $zf(-100,"/SHELL","git", "-C", remoteDir, "config", "user.email", "[email protected]")
+    do $zf(-100,"/SHELL","git", "-C", remoteDir, "config", "user.name", "Unit Test")
+    do $zf(-100,"/SHELL","git", "-C", remoteDir, "checkout", "-b", "live")
+    do ..WriteFile(remoteDir_"/cls/TestGit/SampleClass1.cls","Class TestGit.SampleClass1 {}")
+    do $zf(-100,"/SHELL","git", "-C", remoteDir, "add", ".")
+    do $zf(-100,"/SHELL","git", "-C", remoteDir, "commit", "-m", "initial commit in remote for unit test")
+    do $$$LogMessage("initialize local repo cloning remote")
+    $$$ThrowOnError(##class(SourceControl.Git.Utils).Clone(remoteDir_"/.git"))
+    do $$$LogMessage("set default merge branch to live and enable basic mode")
+    set settings = ##class(SourceControl.Git.Settings).%New()
+    set settings.defaultMergeBranch = "live"
+    set settings.basicMode = "system"
+    set settings.systemBasicMode = 1
+    $$$ThrowOnError(settings.%Save())
+    do $$$LogMessage("check out live branch on local")
+    $$$ThrowOnError(##class(SourceControl.Git.Utils).SwitchBranch("live"))
+    do $$$LogMessage("create a class through IRIS, add it to source control, and sync")
+    do $System.OBJ.Delete("TestGit.SampleClass2")
+    set classDef = ##class(%Dictionary.ClassDefinition).%New("TestGit.SampleClass2")
+    $$$ThrowOnError(classDef.%Save())
+    $$$ThrowOnError($System.OBJ.Compile("TestGit.SampleClass2"))
+    $$$ThrowOnError(##class(SourceControl.Git.Utils).AddToSourceControl("TestGit.SampleClass2.cls"))
+    $$$ThrowOnError(##class(SourceControl.Git.Utils).Sync("should not commit"))
+    do $$$LogMessage("sync should NOT have committed the new file since we are on the live branch.")
+    do $$$AssertTrue(##class(SourceControl.Git.Change).IsUncommitted(##class(SourceControl.Git.Utils).FullExternalName("TestGit.SampleClass2.cls")))
+    do $$$LogMessage("now, check out an interface branch")
+    $$$ThrowOnError(##class(SourceControl.Git.Utils).NewBranch("interface"))
+    do $$$LogMessage("simulate another developer's change going live")
+    do ..WriteFile(remoteDir_"/cls/TestGit/SampleClass1.cls","Class TestGit.SampleClass1 { Parameter foo = ""bar""; }")
+    do $zf(-100,"/SHELL","git", "-C", remoteDir, "add", ".")
+    do $zf(-100,"/SHELL","git", "-C", remoteDir, "commit", "-m", "initial commit in remote for unit test")
+    do $$$LogMessage("check out an interface branch and sync")
+    $$$ThrowOnError(##class(SourceControl.Git.Utils).Sync("should commit"))
+    do $$$LogMessage("sync should have rebased the other developer's change, and committed the new file.")
+    do $$$AssertEquals(##class(TestGit.SampleClass1).#foo, "bar")
+    do $$$AssertNotTrue(##class(SourceControl.Git.Change).IsUncommitted(##class(SourceControl.Git.Utils).FullExternalName("TestGit.SampleClass2.cls")))
+    do $$$LogMessage("simulate a merge request on the remote from the interface branch to live.")
+    do $zf(-100,"/SHELL","git", "-C", remoteDir, "merge", "interface")
+    do $$$AssertTrue(##class(%File).Exists(remoteDir_"/cls/TestGit/SampleClass2.cls"))
+}
+
+}