├── %SourceControl
    ├── Git.cls.xml
    └── Git
    │   ├── Test
    │       ├── AddRemove.cls.xml
    │       └── Git.cls.xml
    │   └── Utils.cls.xml
├── LICENSE.md
├── README.md
├── cache-tort-git.prj.xml
├── csp
    └── gitprojectsettings.csp.xml
└── sc-list.txt


/%SourceControl/Git.cls.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <Export generator="Cache" version="25">
  3 | <Class name="%SourceControl.Git">
  4 | <Import>%SourceControl.Git</Import>
  5 | <Super>%Studio.Extension.Base</Super>
  6 | <TimeCreated>62655,58027.787011</TimeCreated>
  7 | 
  8 | <XData name="Menu">
  9 | <Data><![CDATA[
 10 | <MenuBase>
 11 | <Menu Name="%SourceMenu" Type="0">
 12 | <MenuItem Name="%Cache-Git-Settings" />
 13 | <MenuItem Name="%Settings" />
 14 | <MenuItem Name="%CreateRepo" Save = "001"/>
 15 | <MenuItem Name="%Clone" Save = "001"/>
 16 | <MenuItem Name="%Commit" Save = "001"/>
 17 | <MenuItem Separator="true"/>
 18 | <MenuItem Name="%Pull" Save = "001"/>
 19 | <MenuItem Name="%Fetch" Save = "001"/>
 20 | <MenuItem Name="%Switch" Save = "001"/>
 21 | <MenuItem Name="%Merge" Save = "001"/>
 22 | <MenuItem Name="%Push" Save = "001"/>
 23 | <MenuItem Separator="true"/>
 24 | <MenuItem Name="%Diff" Save = "001"/>
 25 | <MenuItem Name="%RepoStatus" Save = "001"/>
 26 | <MenuItem Name="%Resolve" Save = "001"/>
 27 | <MenuItem Name="%Revert" Save = "001"/>
 28 | <MenuItem Name="%Log" Save = "001"/>
 29 | <MenuItem Separator="true"/>
 30 | <MenuItem Name="%StashSave" Save = "001"/>
 31 | <MenuItem Name="%StashPop" Save = "001"/>
 32 | <MenuItem Separator="true"/>
 33 | <MenuItem Name="%Export" Save = "001" />
 34 | <MenuItem Name="%ExportForce" Save = "001" />
 35 | <MenuItem Name="%Import" Save = "001" />
 36 | <MenuItem Name="%ImportForce" Save = "001" />
 37 | <MenuItem Separator="true"/>
 38 | <MenuItem Name="%OpenRepoFolder" Save = "001" />
 39 | </Menu>
 40 | <Menu Name="%SourceMenuContext" Type="1">
 41 | <MenuItem Name="%AddToSC"/>
 42 | <MenuItem Name="%RemoveFromSC"/>
 43 | <MenuItem Name="%Diff" Save = "001"/>
 44 | <MenuItem Name="%Blame" Save = "001"/>
 45 | </Menu>
 46 | </MenuBase>
 47 | ]]></Data>
 48 | </XData>
 49 | 
 50 | <Method name="UserAction">
 51 | <FormalSpec><![CDATA[Type:%Integer,Name:%String,InternalName:%String,SelectedText:%String,&Action:%String,&Target:%String,&Msg:%String,&Reload:%Boolean]]></FormalSpec>
 52 | <ReturnType>%Status</ReturnType>
 53 | <Implementation><![CDATA[
 54 | 	#dim ec As %Status = $$$OK
 55 | 	#dim menu As %Status = $Piece(Name, ",", 1)
 56 | 	if menu '= "%SourceMenu", menu'="%SourceMenuContext" {
 57 | 		quit $$$OK
 58 | 	}
 59 | 	set InternalName = ##class(Utils).NormalizeInternalName(InternalName)
 60 | 	set ec = ##class(Utils).UserAction(InternalName, Name, .Target, .Action, .Reload)
 61 | 	quit ec
 62 | ]]></Implementation>
 63 | </Method>
 64 | 
 65 | <Method name="OnSourceMenuItem">
 66 | <FormalSpec><![CDATA[name:%String,&Enabled:%String,&DisplayName:%String]]></FormalSpec>
 67 | <ReturnType>%Status</ReturnType>
 68 | <Implementation><![CDATA[
 69 | 	if name = "%Cache-Git-Settings" {
 70 | 		// We always show Settings
 71 | 		set DisplayName = "Settings"
 72 | 		quit $$$OK
 73 | 	} 
 74 | 	if name = "%Settings" && ##class(Utils).GitBinExists() {
 75 | 		set DisplayName = "TortoiseGit Settings"
 76 | 		quit $$$OK
 77 | 	}
 78 | 	
 79 | 	if ##class(Utils).NeedSettings() {
 80 | 		set Enabled = -1
 81 | 		quit $$$OK
 82 | 	}
 83 | 	if ##class(Utils).IsNamespaceInGit() {
 84 | 		if name = "%Export" {
 85 | 			set DisplayName = "Export All"
 86 | 		} elseif name="%ExportForce" {
 87 | 			set DisplayName = "Export All Force"
 88 | 		} elseif name = "%Import" {
 89 | 			set DisplayName = "Import All"
 90 | 		} elseif name = "%ImportForce" {
 91 | 			set DisplayName = "Import All Force"
 92 | 		}elseif name = "%RepoStatus" && ##class(Utils).GitBinExists() {
 93 | 			set DisplayName = "Check for modifications"
 94 | 		}elseif name = "%OpenRepoFolder" {
 95 | 			set DisplayName = "Open Repo Folder"
 96 | 		}
 97 | 		elseif ##class(Utils).IsMenuGitCommand(name) && ##class(Utils).GitBinExists() {
 98 | 			set DisplayName = $case(name,"%StashSave":"Stash save",
 99 | 			                             "%StashPop":"Stash pop",
100 | 			                             :$Extract(name, 2, *))
101 | 		} 
102 | 		else {
103 | 			set Enabled = -1
104 | 		}
105 | 	} elseif ##class(Utils).GitBinExists() { 
106 | 		if name = "%CreateRepo" {
107 | 			set DisplayName = "Create Repo"
108 | 		} elseif name = "%Clone" {
109 | 			set DisplayName = "Clone"
110 | 		} else {
111 | 			set Enabled = -1
112 | 		}
113 | 	} else {
114 | 		set Enabled = -1 
115 | 	}
116 | 	quit $$$OK
117 | ]]></Implementation>
118 | </Method>
119 | 
120 | <Method name="OnSourceMenuContextItem">
121 | <FormalSpec><![CDATA[itemName:%String,menuItemName:%String,&Enabled:%String,&DisplayName:%String]]></FormalSpec>
122 | <ReturnType>%Status</ReturnType>
123 | <Implementation><![CDATA[
124 | 	set:menuItemName="%AddToSC" DisplayName = "Add to SourceControl"
125 | 	set:menuItemName="%RemoveFromSC" DisplayName = "Remove from SourceControl"
126 | 	
127 | 	if (itemName = "") || '##class(Utils).IsNamespaceInGit() {
128 | 		set Enabled = -1
129 | 	}elseif $F(itemName,",") > 0 { //if more than one item is selected, we can only add/remove, no diff or blame
130 | 		set Enabled = $case(menuItemName,"%AddToSC":1,"%RemoveFromSC":1,:-1)
131 | 	
132 | 	}elseif ##class(Utils).IsInSourceControl(##class(Utils).NormalizeInternalName(itemName)) {
133 | 		set Enabled = $Case(menuItemName, "%AddToSC":-1,:1)
134 | 	} else {
135 | 		set Enabled = $Case(menuItemName, "%AddToSC":1,:-1)
136 | 	}
137 | 	quit $$$OK
138 | ]]></Implementation>
139 | </Method>
140 | 
141 | <Method name="OnMenuItem">
142 | <Description><![CDATA[
143 | This is called for every menu item returned to Studio to allow the menu to be enabled/disabled without
144 | having to write a custom query for <query>MenuItems</query>. The <var>DisplayName</var> of this menu is
145 | also passed by reference and this may be modified to change the appearance of this menu item. The <var>MenuName</var>
146 | is the main menu name then the submenu name separated by a ','. If <var>Enabled</var> is set to -1 then it will remove
147 | this menu item from the list totally, 0 will gray the menu item out and the default 1 will display the menu item as normal.]]></Description>
148 | <FormalSpec><![CDATA[MenuName:%String,InternalName:%String,SelectedText:%String,&Enabled:%Boolean,&DisplayName:%String]]></FormalSpec>
149 | <ReturnType>%Status</ReturnType>
150 | <Implementation><![CDATA[
151 | 	#dim menu As %String= $Piece(MenuName,",")
152 | 	#dim name As %String = $Piece(MenuName,",",2)
153 | 	if menu = "%SourceMenuContext", name = "" {
154 | 		set DisplayName = "Git"
155 | 	}
156 | 	if menu = "%SourceMenu", name = "" {
157 | 		set DisplayName = "Git"
158 | 	}
159 | 	#dim ec As %Status = $$$OK
160 | 
161 | 	if menu = "%SourceMenu" {
162 | 		set ec = ..OnSourceMenuItem(name, .Enabled, .DisplayName)
163 | 	}elseif menu = "%SourceMenuContext" {
164 | 		set ec = ..OnSourceMenuContextItem(InternalName, name, .Enabled, .DisplayName)
165 | 	}
166 | 	Quit ec
167 | ]]></Implementation>
168 | </Method>
169 | 
170 | <Method name="OnBeforeLoad">
171 | <Description>
172 | This is called before the actual load of data to give the chance
173 | to load the item from an external format.</Description>
174 | <FormalSpec>InternalName:%String</FormalSpec>
175 | <ReturnType>%Status</ReturnType>
176 | <Implementation><![CDATA[
177 | 	set InternalName = ##class(Utils).NormalizeInternalName(InternalName)
178 | 	if ##class(Utils).IsInSourceControl(InternalName) {
179 | 		quit ##class(Utils).ImportItem(InternalName)
180 | 	}
181 | 	quit $$$OK
182 | ]]></Implementation>
183 | </Method>
184 | 
185 | <Method name="OnAfterSave">
186 | <Description>
187 | This is called after the item has been saved to the database.
188 | It may be passed a reference to the object representing the item
189 | just saved. It can be use to export this documement to an external form for example.</Description>
190 | <FormalSpec>InternalName:%String,Object:%RegisteredObject=$$$NULLOREF</FormalSpec>
191 | <ReturnType>%Status</ReturnType>
192 | <Implementation><![CDATA[
193 | 	set InternalName = ##class(Utils).NormalizeInternalName(InternalName)
194 | 	if ##class(Utils).IsNamespaceInGit() && ..IsInSourceControl(InternalName) {
195 | 		$$$QuitOnError(##class(Utils).RemoveRoutineTSH(InternalName))
196 | 		quit ##class(Utils).ExportItem(InternalName)
197 | 	} else {
198 | 		quit $$$OK
199 | 	}
200 | ]]></Implementation>
201 | </Method>
202 | 
203 | <Method name="OnAfterCompile">
204 | <Description>
205 | Called after the compile of the item is done.</Description>
206 | <FormalSpec>InternalName:%String</FormalSpec>
207 | <ReturnType>%Status</ReturnType>
208 | <Implementation><![CDATA[	Quit ..OnAfterSave(InternalName)
209 | ]]></Implementation>
210 | </Method>
211 | 
212 | <Method name="IsInSourceControl">
213 | <Description>
214 | Returns true if this item is in source control and false otherwise.</Description>
215 | <CodeMode>expression</CodeMode>
216 | <FormalSpec>InternalName:%String</FormalSpec>
217 | <ReturnType>%Boolean</ReturnType>
218 | <Implementation><![CDATA[InternalName'="" && ##class(Utils).IsInSourceControl(##class(Utils).NormalizeInternalName(InternalName))
219 | ]]></Implementation>
220 | </Method>
221 | 
222 | <Method name="OnAfterDelete">
223 | <Description>
224 | Called after an item is deleted.</Description>
225 | <FormalSpec>InternalName:%String</FormalSpec>
226 | <ReturnType>%Status</ReturnType>
227 | <Implementation><![CDATA[
228 | 	set InternalName = ##class(Utils).NormalizeInternalName(InternalName)
229 | 	if ##class(Utils).IsInSourceControl(InternalName) {
230 | 		quit ##class(Utils).DeleteExternalFile(InternalName)
231 | 	}
232 | 	quit $$$OK
233 | ]]></Implementation>
234 | </Method>
235 | </Class>
236 | </Export>
237 | 


--------------------------------------------------------------------------------
/%SourceControl/Git/Test/AddRemove.cls.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <Export generator="Cache" version="25">
 3 | <Class name="%SourceControl.Git.Test.AddRemove">
 4 | <Import>%SourceControl.Git</Import>
 5 | <Super>%UnitTest.TestCase</Super>
 6 | <TimeCreated>63607,51627.861648</TimeCreated>
 7 | 
 8 | <Method name="TestMac">
 9 | <Implementation><![CDATA[
10 | 	do $$$AssertEquals(##class(Utils).IsInSourceControl("test.mac"),0)
11 | 	do $$$AssertStatusOK(##class(Utils).AddToSourceControl("test.mac"))
12 | 	do $$$AssertEquals(##class(Utils).IsInSourceControl("test.mac"),1)
13 | 	do $$$AssertEquals(##class(Utils).IsInSourceControl("test.MAC"),1)
14 | 	do $$$AssertStatusOK(##class(Utils).RemoveFromSourceControl("test.mac"))
15 | 	do $$$AssertEquals(##class(Utils).IsInSourceControl("test.mac"),0)
16 | ]]></Implementation>
17 | </Method>
18 | 
19 | <Method name="TestMACInUpperCase">
20 | <Implementation><![CDATA[
21 | 	do $$$AssertEquals(##class(Utils).IsInSourceControl("test.mac"),0)
22 | 	do $$$AssertStatusOK(##class(Utils).AddToSourceControl("test.MAC"))
23 | 	do $$$AssertEquals(##class(Utils).IsInSourceControl("test.mac"),1)
24 | 	do $$$AssertEquals(##class(Utils).IsInSourceControl("test.MAC"),1)
25 | 	do $$$AssertStatusOK(##class(Utils).RemoveFromSourceControl("test.mac"))
26 | 	do $$$AssertEquals(##class(Utils).IsInSourceControl("test.mac"),0)
27 | ]]></Implementation>
28 | </Method>
29 | 
30 | <Method name="OnBeforeAllTests">
31 | <ReturnType>%Status</ReturnType>
32 | <Implementation><![CDATA[
33 | 	if '##class(%Routine).Exists("test.mac") {
34 | 		set r = ##class(%Routine).%New("test.mac")
35 | 		do r.WriteLine(" write 22,!")
36 | 		do r.Save()
37 | 		do r.Compile()
38 | 	}
39 | 	quit $$$OK
40 | ]]></Implementation>
41 | </Method>
42 | </Class>
43 | </Export>
44 | 


--------------------------------------------------------------------------------
/%SourceControl/Git/Test/Git.cls.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <Export generator="Cache" version="25">
 3 | <Class name="%SourceControl.Git.Test.Git">
 4 | <Abstract>1</Abstract>
 5 | <TimeCreated>63607,51454.905525</TimeCreated>
 6 | 
 7 | <Method name="runall">
 8 | <ClassMethod>1</ClassMethod>
 9 | <Implementation><![CDATA[
10 | 	Set ^UnitTestRoot = $G(^UnitTestRoot,"C:\UnitTests")
11 |     set tortgitRoot = ^UnitTestRoot_"\tortgit\"
12 |     d ##class(%File).CreateDirectoryChain(tortgitRoot)
13 |     try {
14 | 	    #dim sc As %Library.Status
15 | 	    $$$TOE(sc,$system.OBJ.Export("%SourceControl.Git.Test.AddRemove.CLS",tortgitRoot_"AddRemove.xml"))
16 | 	    
17 | 	    $$$TOE(sc,##class(%UnitTest.Manager).RunTestSuites("tortgit", "/noload/nodelete",""))
18 |     }catch ex {
19 | 	   #dim ex As %Exception.StatusException
20 | 	   w ex.DisplayString(),!
21 |     }
22 | ]]></Implementation>
23 | </Method>
24 | </Class>
25 | </Export>
26 | 


--------------------------------------------------------------------------------
/%SourceControl/Git/Utils.cls.xml:
--------------------------------------------------------------------------------
   1 | <?xml version="1.0" encoding="UTF-8"?>
   2 | <Export generator="Cache" version="25">
   3 | <Class name="%SourceControl.Git.Utils">
   4 | <Abstract>1</Abstract>
   5 | <IncludeCode>%occStatus,%occErrors</IncludeCode>
   6 | <ProcedureBlock>1</ProcedureBlock>
   7 | <TimeCreated>62657,53384.637236</TimeCreated>
   8 | 
   9 | <Parameter name="Storage">
  10 | <Default>^Git</Default>
  11 | </Parameter>
  12 | 
  13 | <Parameter name="InstallNamespace">
  14 | <Default>%SYS</Default>
  15 | </Parameter>
  16 | 
  17 | <Parameter name="Slash">
  18 | <Expression>$case($system.Version.GetOS(),"Windows":"\",:"/")</Expression>
  19 | </Parameter>
  20 | 
  21 | <Parameter name="SCListFilename">
  22 | <Description>
  23 | Name of the file with version controlled items</Description>
  24 | <Default>sc-list.txt</Default>
  25 | </Parameter>
  26 | 
  27 | <Parameter name="GitMenuItems">
  28 | <Default>,%Settings,%Commit,%Pull,%Fetch,%Switch,%Merge,%Push,%Diff,%RepoStatus,%Resolve,%Revert,%Log,%StashSave,%StashPop,</Default>
  29 | </Parameter>
  30 | 
  31 | <Parameter name="ImportAfterGitMenuItems">
  32 | <Default>,%Clone,%Commit,%Pull,%Fetch,%Push,%Resolve,%StashPop,</Default>
  33 | </Parameter>
  34 | 
  35 | <Parameter name="GitContextMenuItems">
  36 | <Default>,%Diff,%Blame,</Default>
  37 | </Parameter>
  38 | 
  39 | <Method name="InstallNamespaceStorage">
  40 | <ClassMethod>1</ClassMethod>
  41 | <CodeMode>expression</CodeMode>
  42 | <ReturnType>%String</ReturnType>
  43 | <Implementation><![CDATA[$Replace(..#Storage,"^","^["""_..#InstallNamespace_"""]")
  44 | ]]></Implementation>
  45 | </Method>
  46 | 
  47 | <Method name="DefaultTemp">
  48 | <Description>
  49 | Returns root temp folder</Description>
  50 | <ClassMethod>1</ClassMethod>
  51 | <CodeMode>expression</CodeMode>
  52 | <ReturnType>%String</ReturnType>
  53 | <Implementation><![CDATA[$Get(@..InstallNamespaceStorage()@("%defaultTemp"), "c:\temp\")
  54 | ]]></Implementation>
  55 | </Method>
  56 | 
  57 | <UDLText name="T">
  58 | <Content><![CDATA[
  59 | // 8012 because this error has corresponding error message
  60 | 
  61 | ]]></Content>
  62 | </UDLText>
  63 | 
  64 | <Method name="MakeError">
  65 | <ClassMethod>1</ClassMethod>
  66 | <CodeMode>expression</CodeMode>
  67 | <FormalSpec>msg:%String</FormalSpec>
  68 | <Private>1</Private>
  69 | <ReturnType>%Status</ReturnType>
  70 | <Implementation><![CDATA[$$$ERROR(8012,"Git",msg)
  71 | ]]></Implementation>
  72 | </Method>
  73 | 
  74 | <Method name="TempFolder">
  75 | <ClassMethod>1</ClassMethod>
  76 | <CodeMode>expression</CodeMode>
  77 | <ReturnType>%String</ReturnType>
  78 | <Implementation><![CDATA[$Get(@..#Storage@("settings","namespaceTemp"),..DefaultTemp()_$Translate($znspace,"%")_..#Slash)
  79 | ]]></Implementation>
  80 | </Method>
  81 | 
  82 | <Method name="GroupByFolder">
  83 | <ClassMethod>1</ClassMethod>
  84 | <CodeMode>expression</CodeMode>
  85 | <ReturnType>%String</ReturnType>
  86 | <Implementation><![CDATA[$Get(@..#Storage@("settings","groupByFolder"), 0)
  87 | ]]></Implementation>
  88 | </Method>
  89 | 
  90 | <Method name="IncludeExtensionInFilename">
  91 | <ClassMethod>1</ClassMethod>
  92 | <CodeMode>expression</CodeMode>
  93 | <ReturnType>%Boolean</ReturnType>
  94 | <Implementation><![CDATA[$Get(@..#Storage@("settings","includeExtensionInFilename"), 1)
  95 | ]]></Implementation>
  96 | </Method>
  97 | 
  98 | <Method name="MappingsNode">
  99 | <ClassMethod>1</ClassMethod>
 100 | <CodeMode>expression</CodeMode>
 101 | <ReturnType>%String</ReturnType>
 102 | <Implementation><![CDATA[$Name(@..#Storage@("settings","mappings"))
 103 | ]]></Implementation>
 104 | </Method>
 105 | 
 106 | <Method name="GitBinExists">
 107 | <ClassMethod>1</ClassMethod>
 108 | <ReturnType>%Boolean</ReturnType>
 109 | <Implementation><![CDATA[
 110 | 	#if $system.Version.GetOS()'="Windows" 
 111 | 	 quit 0
 112 | 	#else 
 113 | 	if '$Data(@..InstallNamespaceStorage()@("%gitBinExists")) {
 114 | 		set @..InstallNamespaceStorage()@("%gitBinExists") = ##class(%File).Exists($Extract(..GitBinPath(),2,*-1))
 115 | 	}
 116 | 	quit @..InstallNamespaceStorage()@("%gitBinExists")
 117 | 	#endif
 118 | ]]></Implementation>
 119 | </Method>
 120 | 
 121 | <Method name="GitBinPath">
 122 | <ClassMethod>1</ClassMethod>
 123 | <ReturnType>%String</ReturnType>
 124 | <Implementation><![CDATA[
 125 |     set binPath = $Get(@..InstallNamespaceStorage()@("%gitBinPath"))
 126 |     quit $case($Extract(binPath),"""":binPath,:""""_binPath_"""")
 127 | ]]></Implementation>
 128 | </Method>
 129 | 
 130 | <Method name="NeedSettings">
 131 | <ClassMethod>1</ClassMethod>
 132 | <CodeMode>expression</CodeMode>
 133 | <ReturnType>%Boolean</ReturnType>
 134 | <Implementation><![CDATA[(..DefaultTemp() = "") ||  (..GitBinPath() = "") ||  (..GitBinPath() = """")
 135 | ]]></Implementation>
 136 | </Method>
 137 | 
 138 | <Method name="InstallNamespace">
 139 | <ClassMethod>1</ClassMethod>
 140 | <CodeMode>expression</CodeMode>
 141 | <ReturnType>%String</ReturnType>
 142 | <Implementation><![CDATA[..#InstallNamespace
 143 | ]]></Implementation>
 144 | </Method>
 145 | 
 146 | <Method name="AddSlash">
 147 | <ClassMethod>1</ClassMethod>
 148 | <FormalSpec>path:%String</FormalSpec>
 149 | <Private>1</Private>
 150 | <ReturnType>%String</ReturnType>
 151 | <Implementation><![CDATA[
 152 | 	if path'="" && ($Extract(path,*)'=..#Slash) {
 153 |         set path = path_..#Slash
 154 |     }
 155 |     quit path
 156 | ]]></Implementation>
 157 | </Method>
 158 | 
 159 | <Method name="UpdateSettings">
 160 | <ClassMethod>1</ClassMethod>
 161 | <FormalSpec><![CDATA[&settings]]></FormalSpec>
 162 | <ReturnType>%Status</ReturnType>
 163 | <Implementation><![CDATA[
 164 |     // we change ^STORAGE to ^["InstallNamespace"]|STORAGE, so we store path to git.exe in one place
 165 |     set @..InstallNamespaceStorage()@("%gitBinPath") = settings("gitBinPath")
 166 |     kill @..InstallNamespaceStorage()@("%gitBinExists")
 167 |     
 168 |     // let's add slash in the end
 169 |     set @..InstallNamespaceStorage()@("%defaultTemp") = ..AddSlash(settings("defaultTemp"))
 170 |     
 171 |     set @..#Storage@("settings","namespaceTemp") = ..AddSlash(settings("namespaceTemp"))
 172 |     set @..#Storage@("settings","groupByFolder") = $case(settings("groupByFolder"), "":"", :1)
 173 |     
 174 |     quit $$$OK
 175 | ]]></Implementation>
 176 | </Method>
 177 | 
 178 | <Method name="GitCommand">
 179 | <ClassMethod>1</ClassMethod>
 180 | <CodeMode>expression</CodeMode>
 181 | <FormalSpec>commandName:%String,itemName:%String=""</FormalSpec>
 182 | <ReturnType>%String</ReturnType>
 183 | <Implementation><![CDATA[
 184 | ..GitBinPath()_" /command:"_commandName_
 185 |                " /path:"""_..TempFolder()_
 186 |                $case(itemName,"":"",:..ExternalName(itemName))_""""_
 187 |                $case(commandName,"clone":" /exactpath:"_..TempFolder(),:"")
 188 | ]]></Implementation>
 189 | </Method>
 190 | 
 191 | <Method name="IsMenuGitCommand">
 192 | <ClassMethod>1</ClassMethod>
 193 | <CodeMode>expression</CodeMode>
 194 | <FormalSpec>menuItemName:%String</FormalSpec>
 195 | <ReturnType>%Boolean</ReturnType>
 196 | <Implementation><![CDATA[$Find(..#GitMenuItems, ","_menuItemName_",") > 0
 197 | ]]></Implementation>
 198 | </Method>
 199 | 
 200 | <Method name="IsContextMenuGitCommand">
 201 | <ClassMethod>1</ClassMethod>
 202 | <CodeMode>expression</CodeMode>
 203 | <FormalSpec>menuItemName:%String</FormalSpec>
 204 | <ReturnType>%Boolean</ReturnType>
 205 | <Implementation><![CDATA[$Find(..#GitContextMenuItems, ","_menuItemName_",") > 0
 206 | ]]></Implementation>
 207 | </Method>
 208 | 
 209 | <Method name="IsImportAfter">
 210 | <ClassMethod>1</ClassMethod>
 211 | <CodeMode>expression</CodeMode>
 212 | <FormalSpec>menuItemName:%String</FormalSpec>
 213 | <ReturnType>%Boolean</ReturnType>
 214 | <Implementation><![CDATA[$Find(..#ImportAfterGitMenuItems, ","_menuItemName_",") > 0
 215 | ]]></Implementation>
 216 | </Method>
 217 | 
 218 | <Method name="UserAction">
 219 | <ClassMethod>1</ClassMethod>
 220 | <FormalSpec><![CDATA[InternalName:%String,MenuName:%String,&Target:%String,&Action:%String,&Reload:%Boolean]]></FormalSpec>
 221 | <ReturnType>%Status</ReturnType>
 222 | <Implementation><![CDATA[
 223 | 	#define Force 1
 224 |     #dim menuName As %String = $Piece(MenuName,",")
 225 |     #dim menuItemName As %String = $Piece(MenuName,",",2)
 226 |     #dim ec As %Status = $$$OK
 227 |     
 228 |     if ..GitBinExists() = 0 && (menuItemName'="%Cache-Git-Settings") && 
 229 |     		($system.Version.GetOS()="Windows") {
 230 |         write !!,"===Path to tortoisegitproc.exe not found: "_..GitBinPath()_"!===",!
 231 |     }
 232 |     
 233 |     if (menuName = "%SourceMenu") {
 234 |         if (menuItemName = "%Cache-Git-Settings") {
 235 |             set Action = 2
 236 |             set Target = ##class(%cspapp.gitprojectsettings).%GetParameter("CSPURL")_"?NSpace="_$znspace_"&Username="_$username
 237 |         }elseif (menuItemName = "%CreateRepo") {
 238 |             if ##class(%File).CreateDirectoryChain(..TempFolder()) {
 239 |                 // cleanup items info
 240 |                 kill @..#Storage@("items")
 241 |                 kill @..#Storage@("TSH")
 242 |                 set Action = 3
 243 |                 set Target = ..GitCommand("repocreate")
 244 |             } else {
 245 |                 set ec = ..MakeError("Unable to create folder "_..TempFolder())
 246 |             }
 247 |         }elseif (menuItemName = "%Export") || (menuItemName = "%ExportForce") {
 248 |             write "==export start==",!
 249 |             set ec = ..ExportAll($case(menuItemName="%ExportForce",1:$$$Force,:0))
 250 |             if ec {
 251 |                 write !,"==export done==",!
 252 |             }
 253 |         }elseif (menuItemName = "%Import") {
 254 |             set ec = ..ImportAll()
 255 |             set Reload = 1
 256 |         }elseif (menuItemName = "%ImportForce") {
 257 |             set ec = ..ImportAll($$$Force)
 258 |             set Reload = 1
 259 |         }elseif (menuItemName = "%Clone") {
 260 |             if ##class(%File).CreateDirectoryChain(..TempFolder()) {
 261 |                 // cleanup items info
 262 |                 kill @..#Storage@("items")
 263 |                 kill @..#Storage@("TSH")
 264 |                 set Action = 3
 265 |                 set Target = ..GitCommand("clone", "")
 266 |             } else {
 267 |                 set ec = ..MakeError("Unable to create folder "_..TempFolder())
 268 |             }
 269 |         }elseif (menuItemName = "%OpenRepoFolder") {
 270 | 	        set Action = 3
 271 | 	        set Target = ..TempFolder()
 272 |     	}elseif ..IsMenuGitCommand(menuItemName) {
 273 |                 set Action = 3
 274 |                 #dim command As %String = $ZConvert($Extract(menuItemName, 2, *), "L")
 275 |                 set ec = $$$OK
 276 |                 if $Data(@..#Storage@("settings","hook"),hook)=1 {
 277 | 	                set $ListBuild(class,method) = hook
 278 | 	                set ec = $classmethod(class, method, command, InternalName)
 279 |                 }
 280 |                 if $$$ISOK(ec) {
 281 |                 	set Target = ..GitCommand(command)
 282 |                 }
 283 |         }
 284 |     }elseif (menuName = "%SourceMenuContext") {
 285 | 	    
 286 | 	    if (..Type(InternalName) = "csp") && ($Extract(InternalName,1) '= "/") {
 287 | 	        set InternalName = "/" _ InternalName
 288 |         }
 289 |         
 290 |         if (menuItemName = "%AddToSC") {
 291 |             set ec = ..AddToSourceControl(InternalName)
 292 |         }elseif (menuItemName = "%RemoveFromSC") {
 293 |             set ec = ..RemoveFromSourceControl(InternalName)
 294 |         }
 295 |         if ..IsContextMenuGitCommand(menuItemName) {
 296 |             set Action = 3
 297 |             set command = $ZConvert($Extract(menuItemName, 2, *), "L")
 298 |             set Target = ..GitCommand(command, InternalName)
 299 |         }
 300 |     }
 301 |     if ..IsImportAfter(menuItemName) && (Action = 3) {
 302 | 	    write "Choose Import All menu after work with Git!", !
 303 |     }
 304 |     //w Target,!
 305 |     quit ec
 306 | ]]></Implementation>
 307 | </Method>
 308 | 
 309 | <Method name="AfterUserAction">
 310 | <ClassMethod>1</ClassMethod>
 311 | <FormalSpec><![CDATA[Type:%Integer,Name:%String,InternalName:%String,Answer:%Integer,Msg:%String="",&Reload:%Boolean]]></FormalSpec>
 312 | <ReturnType>%Status</ReturnType>
 313 | <Implementation><![CDATA[    quit $$$OK
 314 | ]]></Implementation>
 315 | </Method>
 316 | 
 317 | <Method name="IsNamespaceInGit">
 318 | <ClassMethod>1</ClassMethod>
 319 | <CodeMode>expression</CodeMode>
 320 | <ReturnType>%Boolean</ReturnType>
 321 | <Implementation><![CDATA[##class(%File).Exists(..TempFolder()_".git")
 322 | ]]></Implementation>
 323 | </Method>
 324 | 
 325 | <Method name="NormalizeFolder">
 326 | <Description><![CDATA[
 327 | replaces any slashes with the ones for current OS<br/>
 328 | removes first slash if present<br/>
 329 | adds last slash if not present<br/>]]></Description>
 330 | <ClassMethod>1</ClassMethod>
 331 | <FormalSpec>folder:%String</FormalSpec>
 332 | <ReturnType>%String</ReturnType>
 333 | <Implementation><![CDATA[
 334 | 	set folder = $Translate(folder, "/", ..#Slash)
 335 | 	set:$Extract(folder)=..#Slash $Extract(folder) = ""
 336 | 	set:$Extract(folder,*)'=..#Slash folder = folder _ ..#Slash
 337 | 	quit folder
 338 | ]]></Implementation>
 339 | </Method>
 340 | 
 341 | <Method name="ExternalName">
 342 | <ClassMethod>1</ClassMethod>
 343 | <FormalSpec>InternalName:%String</FormalSpec>
 344 | <ReturnType>%String</ReturnType>
 345 | <Implementation><![CDATA[
 346 |     set name = $Translate(InternalName, "/", ..#Slash)
 347 | 
 348 |     // lower case for extensions
 349 |     #dim extension As %String = $ZConvert($Piece(name,".",$Length(name,".")),"L")
 350 |     #dim baseName As %String = $piece(name,".",1,$length(name,".")-1)
 351 |     
 352 |     #dim groupByFolder As %Boolean = ..GroupByFolder()
 353 |     if ..IncludeExtensionInFilename() {
 354 |         set extensionSuffix = "." _ extension
 355 |     }
 356 |     else {
 357 |         set extensionSuffix = ""
 358 |     }
 359 | 
 360 |     // we shall put classes in different folders
 361 |     if extension = "cls" {
 362 |         set name = $Translate( baseName, ".", ..#Slash) _ extensionSuffix
 363 |     } elseif groupByFolder {
 364 | 	    // If groupByFolder = 1 then we put inc, mac, int in corresponding folder, not in root.
 365 | 		// For example project.include.inc will be placed in project\include.inc.xml
 366 |         set sep = $Case(extension, "dfi" : "-", : ".")
 367 | 	    set name = $Translate(baseName, sep, ..#Slash) _ extensionSuffix
 368 |     }
 369 |     else {
 370 |         set name = baseName _ extensionSuffix
 371 |     }
 372 |     
 373 |     // we shall delete csp-app from csp files
 374 |     if $Extract(name, 1) = ..#Slash {
 375 |         set $Extract(name, 1) = ""
 376 |     }
 377 |     if $Piece(name, ..#Slash, 1) = "csp" {
 378 |         set $Piece(name, ..#Slash, 1, 2) = "csp"
 379 |     }
 380 | 
 381 |     set mappingsNode = ..MappingsNode()
 382 |     set mappings = $Data(@mappingsNode, rootFolder)
 383 |     
 384 |     if mappings#10 = 1 { // value in root
 385 | 	    set rootFolder = ..NormalizeFolder(rootFolder)
 386 |     }
 387 |     
 388 |     if mappings >= 10 { //values in leaves
 389 |    	    set type = ..Type(InternalName)
 390 |    	    
 391 | 	    if $Data(@mappingsNode@(type), folder) {
 392 | 		    set folder = ..NormalizeFolder(folder)
 393 | 	    }
 394 |     }
 395 |     
 396 |     set name = $Get(rootFolder) _ $Get(folder) _ name
 397 |     
 398 |     // write "name=",name,!
 399 |     // write "external name = ", $Translate(name," *?","___")_".xml", !
 400 |     quit $Translate(name," *?","___")_".xml"
 401 | ]]></Implementation>
 402 | </Method>
 403 | 
 404 | <Method name="AddToSourceControl">
 405 | <ClassMethod>1</ClassMethod>
 406 | <FormalSpec>InternalName:%String</FormalSpec>
 407 | <ReturnType>%Status</ReturnType>
 408 | <Implementation><![CDATA[
 409 |     #dim i As %Integer
 410 |     #dim ec As %Status = $$$OK
 411 |     for i = 1:1:$Length(InternalName, ",") {
 412 |         #dim item As %String = ..NormalizeExtension($Piece(InternalName, ",", i))
 413 |         set @..#Storage@("items", item) = ""
 414 |         #dim sc As %Status =  ..ExportItem(item)
 415 |         if 'sc {
 416 |             set ec = $$$ADDSC(ec, sc)
 417 |         }
 418 |     }
 419 |     set ec = $$$ADDSC(ec, ..ExportSCList())
 420 |     quit ec
 421 | ]]></Implementation>
 422 | </Method>
 423 | 
 424 | <Method name="DeleteExternalsForItem">
 425 | <ClassMethod>1</ClassMethod>
 426 | <FormalSpec>InternalName:%String</FormalSpec>
 427 | <ReturnType>%Status</ReturnType>
 428 | <Implementation><![CDATA[
 429 |     #dim type As %String = ..Type(InternalName)
 430 |     #dim ec As %Status = $$$OK
 431 |     if (type = "prj") || (type = "pkg") || (type = "csp" && ..IsCspFolder(InternalName)) {
 432 |         // we delete complex items
 433 |         
 434 |         //get all item in files
 435 |         #dim itemsList
 436 |         $$$QuitOnError(..ListItemsInFiles(.itemsList))
 437 |         
 438 |         #dim item As %String = ""
 439 |         //for all item in files
 440 |         for  {
 441 |             set item = $Order(itemsList(item))
 442 |             quit:item=""
 443 |             
 444 |             //if item is not in sc -- delete file
 445 |             if '..IsInSourceControl(item) {
 446 |                 #dim sc As %Status = ..DeleteExternalFile(item)
 447 |                 if 'sc {
 448 |                     set ec = $$$ADDSC(ec, sc)
 449 |                 }
 450 |             }
 451 |         }
 452 |     } else {
 453 |         set ec = ..DeleteExternalFile(InternalName)
 454 |     }
 455 |     quit ec
 456 | ]]></Implementation>
 457 | </Method>
 458 | 
 459 | <Method name="RemoveFromSourceControl">
 460 | <ClassMethod>1</ClassMethod>
 461 | <FormalSpec>InternalName:%String</FormalSpec>
 462 | <ReturnType>%Status</ReturnType>
 463 | <Implementation><![CDATA[
 464 |     #dim sc As %Status = $$$OK
 465 |     for i = 1:1:$Length(InternalName, ",") {
 466 | 	    #dim tsc As %Status = $$$OK
 467 | 	    set item = $Piece(InternalName, ",", i)
 468 | 	    if $Data(@..#Storage@("items", ..NormalizeExtension(item))) {
 469 | 		    set item = ..NormalizeExtension(item)
 470 | 	    }
 471 | 	    
 472 | 	    if $Data(@..#Storage@("items", item)) {
 473 | 	        kill @..#Storage@("items", item)
 474 | 	        set tsc = ..DeleteExternalsForItem(item)
 475 | 	        do ..RemoveFolderIfEmpty(..TempFolder())
 476 | 	        set tsc = $$$ADDSC(tsc, ..ExportSCList())
 477 | 	    } else {
 478 | 	        #dim parentElement As %String = ""
 479 | 	        if ..IsInSourceControl(item, .parentElement) {
 480 | 	            set tsc = ..MakeError(item _ " is contained in "_parentElement_" that tracked by SourceControl")
 481 | 	        }else {
 482 | 	            set tsc = ..MakeError(item _ " is not in SourceControl")
 483 | 	        }
 484 | 	    }
 485 | 	    set sc = $$$ADDSC(tsc, sc)
 486 |     }
 487 | 
 488 |     quit sc
 489 | ]]></Implementation>
 490 | </Method>
 491 | 
 492 | <Method name="IsCspFolder">
 493 | <ClassMethod>1</ClassMethod>
 494 | <FormalSpec>InternalName:%String</FormalSpec>
 495 | <ReturnType>%Boolean</ReturnType>
 496 | <Implementation><![CDATA[
 497 |     #dim extension = $Piece(InternalName, ".", $Length(InternalName, "."))
 498 |     quit:extension="csp" 0
 499 |     
 500 |     #dim filename = $system.CSP.GetFileName(InternalName_"/")
 501 |     if filename = "" && ($Extract(InternalName,1) '= "/") {
 502 | 	    set filename = $system.CSP.GetFileName("/"_InternalName_"/")
 503 |     }
 504 |     quit filename'="" && ##class(%File).DirectoryExists(filename)
 505 | ]]></Implementation>
 506 | </Method>
 507 | 
 508 | <Method name="Type">
 509 | <Description><![CDATA[
 510 | pkg -- package<br/>
 511 | prj -- project<br/>
 512 | csp -- csp-page or csp-folder. See <Method>IsCspFolder</Method><br/>
 513 | csp -- any static file from csp-folder ]]></Description>
 514 | <ClassMethod>1</ClassMethod>
 515 | <FormalSpec>InternalName:%String</FormalSpec>
 516 | <ReturnType>%String</ReturnType>
 517 | <Implementation><![CDATA[
 518 |     #dim extension As %String = $ZConvert($Piece(InternalName,".",$Length(InternalName,".")),"L")
 519 |     #dim type As %String = extension
 520 |     
 521 |     if ($Extract(InternalName, 1, 4) = "/csp") 
 522 |           || ($Find(InternalName,".") = 0) 
 523 |           || ($Find(InternalName,"/") > 0) {
 524 | 	          //we need to double-check
 525 | 	          //Sometimes (see NormalizeInternalName) Studio passes routine names as /Package/SubPackage/Routine.mac
 526 | 	          //Generally speaking this can be static file
 527 | 	          if (type = "mac") || (type = "inc") || (type = "int") {
 528 | 		          #dim filename = $system.CSP.GetFileName(InternalName)
 529 | 		          if ##class(%File).Exists(filename) {
 530 | 			          set type = "csp"
 531 | 		          }
 532 | 	          } else {
 533 |         			set type ="csp"
 534 | 	          }
 535 |     }
 536 |    
 537 |     quit type
 538 | ]]></Implementation>
 539 | </Method>
 540 | 
 541 | <Method name="NameWithoutExtension">
 542 | <ClassMethod>1</ClassMethod>
 543 | <CodeMode>expression</CodeMode>
 544 | <FormalSpec>InternalName:%String</FormalSpec>
 545 | <ReturnType>%String</ReturnType>
 546 | <Implementation><![CDATA[$Piece(InternalName, ".", 1, $Length(InternalName,".")-1)
 547 | ]]></Implementation>
 548 | </Method>
 549 | 
 550 | <Method name="IsClassInPackage">
 551 | <Description>
 552 | packageName without extension</Description>
 553 | <ClassMethod>1</ClassMethod>
 554 | <CodeMode>expression</CodeMode>
 555 | <FormalSpec>ClassName:%String,packageName:%String</FormalSpec>
 556 | <ReturnType>%Boolean</ReturnType>
 557 | <Implementation><![CDATA[$Extract(ClassName, 1, $Length(packageName)) = packageName
 558 | ]]></Implementation>
 559 | </Method>
 560 | 
 561 | <Method name="IsItemInProject">
 562 | <Description>
 563 | projectName without extension</Description>
 564 | <ClassMethod>1</ClassMethod>
 565 | <FormalSpec>InternalName:%String,projectName:%String</FormalSpec>
 566 | <ReturnType>%Boolean</ReturnType>
 567 | <Implementation><![CDATA[
 568 |     // we should check two cases
 569 |     // direct inclusion
 570 |     // inclusion in package or csp-folder that contained in project
 571 |     #dim type As %String = ..Type(InternalName)
 572 |     //w InternalName, "->"
 573 |     #dim name As %String = $case(type, "cls": ..NameWithoutExtension(InternalName), 
 574 |                                        "pkg": $Translate(..NameWithoutExtension(InternalName), "/", "."), 
 575 |                                        "csp": $Extract(InternalName, 2, *),
 576 |                                        :InternalName)
 577 |     if $Extract(name) = "." && (type = "pkg") {
 578 |         set $Extract(name) = ""
 579 |     }
 580 |     
 581 |     //w name, " "
 582 |     #dim checkId = projectName_"||"_name_"||"_$ZConvert(type,"U")
 583 |     //w checkId
 584 |     #dim isItemInProject As %Boolean = ##class(%Studio.ProjectItem).%ExistsId(checkId)
 585 |     //w " ", isItemInProject, !
 586 |     
 587 |     #dim i As %Integer
 588 |     if 'isItemInProject && ((type = "cls") || (type="pkg")) {
 589 |         for i = 1:1:$Length(name, ".") {
 590 |             set checkId = projectName_"||"_$Piece(name, ".", 1, i)_"||PKG"
 591 |             //w checkId, !
 592 |             if ##class(%Studio.ProjectItem).%ExistsId(checkId) {
 593 |                 set isItemInProject = 1
 594 |                 quit
 595 |             }
 596 |         }
 597 |     }
 598 |     
 599 |     if 'isItemInProject && (type = "csp") {
 600 |         for i = 1:1:$Length(name, "/") {
 601 |             set checkId = projectName_"||"_$Piece(name, "/", 1, i)_"||DIR"
 602 |             
 603 |             if ##class(%Studio.ProjectItem).%ExistsId(checkId) {
 604 |                 set isItemInProject = 1
 605 |                 quit
 606 |             }
 607 |         }
 608 |     }
 609 |     quit isItemInProject
 610 | ]]></Implementation>
 611 | </Method>
 612 | 
 613 | <Method name="IsItemInCSPFolder">
 614 | <ClassMethod>1</ClassMethod>
 615 | <CodeMode>expression</CodeMode>
 616 | <FormalSpec>InternalName:%String,cspFolder:%String</FormalSpec>
 617 | <ReturnType>%Boolean</ReturnType>
 618 | <Implementation><![CDATA[$Extract(InternalName, 1, $Length(cspFolder)) = cspFolder
 619 | ]]></Implementation>
 620 | </Method>
 621 | 
 622 | <Method name="FindInPackages">
 623 | <ClassMethod>1</ClassMethod>
 624 | <FormalSpec><![CDATA[InternalName:%String,&sourceControlItem:%String]]></FormalSpec>
 625 | <ReturnType>%Boolean</ReturnType>
 626 | <Implementation><![CDATA[
 627 |     #dim item As %String = ""
 628 |     #dim found As %Boolean = 0
 629 |     for  {
 630 |         set item = $Order(@..#Storage@("items", item))
 631 |         quit:item=""
 632 |         continue:..Type(item)'="pkg"
 633 |         #dim packageName As %String = ..NameWithoutExtension(item)
 634 | 
 635 |         if ..IsClassInPackage(InternalName, packageName) {
 636 |             set found = 1
 637 |             set sourceControlItem = packageName
 638 |             quit
 639 |         }
 640 |     }
 641 |     quit found
 642 | ]]></Implementation>
 643 | </Method>
 644 | 
 645 | <Method name="FindInProjects">
 646 | <ClassMethod>1</ClassMethod>
 647 | <FormalSpec><![CDATA[InternalName:%String,&sourceControlItem:%String]]></FormalSpec>
 648 | <ReturnType>%Boolean</ReturnType>
 649 | <Implementation><![CDATA[
 650 |     #dim item As %String = ""
 651 |     #dim found As %Boolean = 0
 652 |     for  {
 653 |         set item = $Order(@..#Storage@("items", item))
 654 |         quit:item=""
 655 |         continue:..Type(item)'="prj"
 656 |         #dim projectName As %String = ..NameWithoutExtension(item)
 657 |         
 658 |         if ..IsItemInProject(InternalName, projectName) {
 659 |             set found = 1
 660 |             set sourceControlItem = projectName
 661 |             quit
 662 |         }
 663 |     }
 664 |     quit found
 665 | ]]></Implementation>
 666 | </Method>
 667 | 
 668 | <Method name="FindInCspFolders">
 669 | <ClassMethod>1</ClassMethod>
 670 | <FormalSpec><![CDATA[InternalName:%String,&sourceControlItem:%String]]></FormalSpec>
 671 | <ReturnType>%Boolean</ReturnType>
 672 | <Implementation><![CDATA[
 673 |     #dim cspFolder As %String = ""
 674 |     #dim found As %Boolean = 0
 675 |     for  {
 676 |         set cspFolder = $Order(@..#Storage@("items", cspFolder))
 677 |         quit:cspFolder=""
 678 |         //no need to check IsCspFolder. It might not exist yet
 679 |         //continue:'(..Type(cspFolder)="csp" && ..IsCspFolder(cspFolder))
 680 |         continue:'(..Type(cspFolder)="csp")
 681 | 
 682 | 
 683 |         
 684 |         if ..IsItemInCSPFolder(InternalName, cspFolder) {
 685 |             set found = 1
 686 |             set sourceControlItem = cspFolder
 687 |             quit 
 688 |         }
 689 |     }
 690 |     quit found
 691 | ]]></Implementation>
 692 | </Method>
 693 | 
 694 | <Method name="IsInSourceControl">
 695 | <ClassMethod>1</ClassMethod>
 696 | <FormalSpec><![CDATA[InternalName:%String,&sourceControlItem:%String]]></FormalSpec>
 697 | <ReturnType>%String</ReturnType>
 698 | <Implementation><![CDATA[
 699 |     #dim isInSourceControl As %Boolean = 1
 700 |     
 701 |     if $Data(@..#Storage@("items", ..NormalizeExtension(InternalName))) {
 702 | 	    set InternalName = ..NormalizeExtension(InternalName)
 703 |     }
 704 |     
 705 |     set isInSourceControl = $Data(@..#Storage@("items", InternalName)) > 0
 706 |     if isInSourceControl {
 707 |         set sourceControlItem = InternalName
 708 |     }else {
 709 |         //if no direct reference maybe we have to look in packages, projects or csp-apps ?
 710 |         //We have three groups of routines
 711 |         //packages for classes
 712 |         //projects for everything
 713 |         //csp-folders for csp and static files
 714 | 
 715 |         #dim type As %String = ..Type(InternalName)
 716 |         if type = "cls" {
 717 | 	        #define StripExtension(%s) $Piece(%s,".",1,$Length(%s, ".") - 1)
 718 | 	        if InternalName'="" && ($$$defClassKeyGet($$$StripExtension(InternalName),$$$cCLASSgeneratedby)'="") {
 719 | 		        set isInSourceControl = 0 // skip generated classes
 720 | 	        } else {
 721 |             	set isInSourceControl = ..FindInPackages(InternalName, .sourceControlItem)
 722 | 	        }
 723 |         } elseif type = "csp" {
 724 | 	        if $Extract(InternalName) '= "/" {
 725 | 		        set InternalName = "/" _ InternalName
 726 | 	        }
 727 |             set isInSourceControl = ..FindInCspFolders(InternalName, .sourceControlItem)
 728 |         }
 729 |         
 730 |         // our last chance to find item -- let's look in projects
 731 |         if 'isInSourceControl {
 732 |             set isInSourceControl = ..FindInProjects(InternalName, .sourceControlItem)
 733 |         }
 734 |     }
 735 |     //w "checking ", $G(type), " ", InternalName, "=", isInSourceControl, !
 736 |     quit isInSourceControl
 737 | ]]></Implementation>
 738 | </Method>
 739 | 
 740 | <Method name="FullExternalName">
 741 | <ClassMethod>1</ClassMethod>
 742 | <CodeMode>expression</CodeMode>
 743 | <FormalSpec>InternalName:%String</FormalSpec>
 744 | <ReturnType>%String</ReturnType>
 745 | <Implementation><![CDATA[..TempFolder()_..ExternalName(InternalName)
 746 | ]]></Implementation>
 747 | </Method>
 748 | 
 749 | <Method name="NormalizeInternalName">
 750 | <ClassMethod>1</ClassMethod>
 751 | <FormalSpec>name:%String</FormalSpec>
 752 | <ReturnType>%String</ReturnType>
 753 | <Implementation><![CDATA[
 754 | 	//Studio passes name of routine with dots as it is in folders
 755 | 	//e.g. Package.SubPackage.Routine.mac has InternalName =  /Package/SubPackage/Routine.mac
 756 | 	//This happens if right-click in Workspace -> Namespace
 757 | 	//If right-click in Workspace -> Project then everything passes ok
 758 | 	//let's fix this
 759 | 	if $Extract(name) '= "/" {
 760 | 		quit name
 761 | 	}
 762 | 	
 763 | 	set type = ..Type(name)
 764 | 	
 765 | 	if (type = "inc") || (type = "mac") || (type = "int") {
 766 | 		set name = $Extract($Translate(name, "/", "."), 2, *)
 767 | 	}
 768 |     quit name
 769 | ]]></Implementation>
 770 | </Method>
 771 | 
 772 | <Method name="NormalizeExtension">
 773 | <ClassMethod>1</ClassMethod>
 774 | <FormalSpec>name:%String</FormalSpec>
 775 | <ReturnType>%String</ReturnType>
 776 | <Implementation><![CDATA[
 777 |     #dim extension = $Piece(name, ".", $Length(name, "."))
 778 |     if $Length(extension) <= 3 {
 779 |         set $Piece(name, ".", $Length(name, ".")) = $ZConvert(extension, "L")
 780 |     }
 781 |     quit name
 782 | ]]></Implementation>
 783 | </Method>
 784 | 
 785 | <Method name="RoutineTSH">
 786 | <ClassMethod>1</ClassMethod>
 787 | <FormalSpec>InternalName:%String</FormalSpec>
 788 | <ReturnType>%String</ReturnType>
 789 | <Implementation><![CDATA[
 790 |     #dim type = ..Type(InternalName)
 791 |     //for csp-files (csp,js,html,css, all that stored in csp/...) we always check for changes in external file
 792 |     #dim tsh = $case(type,"csp":"",:$Get(@..#Storage@("TSH", ..NormalizeExtension(InternalName))))
 793 |     if tsh = "" {
 794 |         #dim ts As %String = ##class(%RoutineMgr).TS(InternalName)
 795 |         if ts '= "" {
 796 |             // prj files have milliseconds in timestamp, so we crop them
 797 |             set tsh = $Piece($ZDateTimeH(ts, 3),".",1)
 798 |         } else {
 799 | 	        set tsh = "1840-12-31 00:00:00"
 800 |         }
 801 |     }
 802 |     quit tsh
 803 | ]]></Implementation>
 804 | </Method>
 805 | 
 806 | <Method name="UpdateRoutineTSH">
 807 | <ClassMethod>1</ClassMethod>
 808 | <FormalSpec>InternalName:%String,tsh:%String</FormalSpec>
 809 | <ReturnType>%Status</ReturnType>
 810 | <Implementation><![CDATA[
 811 |     set @..#Storage@("TSH", ..NormalizeExtension(InternalName)) = $Get(tsh, $Horolog)
 812 |     quit $$$OK
 813 | ]]></Implementation>
 814 | </Method>
 815 | 
 816 | <Method name="RemoveRoutineTSH">
 817 | <ClassMethod>1</ClassMethod>
 818 | <FormalSpec>InternalName:%String</FormalSpec>
 819 | <ReturnType>%Status</ReturnType>
 820 | <Implementation><![CDATA[
 821 |     kill @..#Storage@("TSH", ..NormalizeExtension(InternalName))
 822 |     quit $$$OK
 823 | ]]></Implementation>
 824 | </Method>
 825 | 
 826 | <Method name="DeleteExternalFile">
 827 | <ClassMethod>1</ClassMethod>
 828 | <FormalSpec>InternalName:%String</FormalSpec>
 829 | <ReturnType>%Status</ReturnType>
 830 | <Implementation><![CDATA[
 831 |     #dim fullName = ##class(Utils).FullExternalName(InternalName)
 832 |     #dim ec As %Status = $$$OK
 833 |     if ##class(%File).Exists(fullName) {
 834 |         set ec = ##class(%File).Delete(fullName)
 835 |         do ..RemoveRoutineTSH(InternalName)
 836 |         write fullName, " for ", InternalName, " deleted",!
 837 |     }
 838 |     Quit ec
 839 | ]]></Implementation>
 840 | </Method>
 841 | 
 842 | <Method name="GetTempFileAndRoutineTS">
 843 | <Description>
 844 | if temp file for InternalName not found return "0,0" in tempFileTSH</Description>
 845 | <ClassMethod>1</ClassMethod>
 846 | <FormalSpec><![CDATA[InternalName:%String,&tempFileTSH:%String,&routineTSH:%String]]></FormalSpec>
 847 | <Implementation><![CDATA[
 848 |     #dim filename As %String = ..FullExternalName(InternalName)
 849 |     set tempFileTSH = ##class(%File).GetFileDateModified(filename)
 850 |     set routineTSH = ..RoutineTSH(InternalName)
 851 |     //file not found or path not found or some other error
 852 |     set:tempFileTSH<0 tempFileTSH = "0,0"
 853 |     set tempFileTSH = $zdatetime(tempFileTSH,3)
 854 |     set routineTSH = $zdatetime(routineTSH,3)
 855 | ]]></Implementation>
 856 | </Method>
 857 | 
 858 | <Method name="IsTempFileOutdated">
 859 | <ClassMethod>1</ClassMethod>
 860 | <FormalSpec>InternalName:%String</FormalSpec>
 861 | <ReturnType>%Boolean</ReturnType>
 862 | <Implementation><![CDATA[
 863 |     do ..GetTempFileAndRoutineTS(InternalName,.tempFileTSH,.routineTSH)
 864 |     quit routineTSH]tempFileTSH
 865 | ]]></Implementation>
 866 | </Method>
 867 | 
 868 | <Method name="IsRoutineOutdated">
 869 | <ClassMethod>1</ClassMethod>
 870 | <FormalSpec>InternalName:%String</FormalSpec>
 871 | <ReturnType>%Boolean</ReturnType>
 872 | <Implementation><![CDATA[
 873 |     do ..GetTempFileAndRoutineTS(InternalName,.tempFileTSH,.routineTSH)
 874 |     quit tempFileTSH]routineTSH
 875 | ]]></Implementation>
 876 | </Method>
 877 | 
 878 | <Method name="FixProjectCspReferences">
 879 | <ClassMethod>1</ClassMethod>
 880 | <FormalSpec>projectName:%String</FormalSpec>
 881 | <ReturnType>%Status</ReturnType>
 882 | <Implementation><![CDATA[
 883 |     #dim loadedProject As %String = $Piece(projectName, ".", 1)
 884 |     // now we should fix reference to csp pages in project items
 885 |     // that is: if project was exported from USER and imported in SAMPLES
 886 |     // then all reference to csp/user/page.csp should be changed to csp/samples/page.csp
 887 |     #dim item As %String =""
 888 |     #dim oldCspApp As %String = ""
 889 |     #dim newCspApp As %String = ""
 890 |     for  {
 891 |         set item = $Order(^oddPROJECT(loadedProject,"Items",item))
 892 |         quit:item=""
 893 |         set type = $Order(^oddPROJECT(loadedProject,"Items",item,""))
 894 |         if type = "CSP" || (type = "DIR") {
 895 |             #dim newitem As %String = item
 896 |             set $Piece(newitem,"/",1,2) = $Extract($system.CSP.GetDefaultApp($znspace),2,*)
 897 |             if newitem '= item {
 898 |                 set ^oddPROJECT(loadedProject,"Items",newitem,type) = ^oddPROJECT(loadedProject,"Items",item,type)
 899 |                 kill ^oddPROJECT(loadedProject,"Items",item,type)
 900 |                 set newCspApp = $Extract($system.CSP.GetDefaultApp($znspace),2,*)
 901 |                 set oldCspApp = $Piece(item,"/",1,2)
 902 |             }
 903 |         }
 904 |     }
 905 |     quit $$$OK
 906 | ]]></Implementation>
 907 | </Method>
 908 | 
 909 | <Method name="ImportItem">
 910 | <Description><![CDATA[
 911 | imports file if version in system is newer then version on disk.
 912 | if <var>force</var> = 1 then imports in any case.]]></Description>
 913 | <ClassMethod>1</ClassMethod>
 914 | <FormalSpec>InternalName:%String,force:%Boolean=0</FormalSpec>
 915 | <ReturnType>%Status</ReturnType>
 916 | <Implementation><![CDATA[
 917 |     //WRITE "Before Load Of: ", InternalName, " ", ..IsInSourceControl(InternalName), !
 918 |     //q:'..IsInSourceControl(InternalName) $$$OK
 919 |     #dim filename As %String = ..FullExternalName(InternalName)
 920 |     #dim fileTSH = ##class(%File).GetFileDateModified(filename)
 921 |     #dim sc As %Status = $$$OK
 922 |  
 923 |     if ..IsRoutineOutdated(InternalName) || force {
 924 |         set sc = $system.OBJ.Load(filename,"-l-d")
 925 |         if sc {
 926 |             set sc = ..UpdateRoutineTSH(InternalName, fileTSH)
 927 |             if ..Type(InternalName) = "prj" {
 928 |                 set sc = $$$ADDSC(sc, ..FixProjectCspReferences(InternalName))
 929 |             }
 930 |             write InternalName," has been imported from ", filename,!
 931 |         } else {
 932 | 	        write "ERROR importing" ,InternalName,!
 933 | 	        do $system.Status.DisplayError(sc)
 934 |         }
 935 |     } else {
 936 | 	    write InternalName, " is the same as on-disk version or newer, skipping import",!
 937 |     }
 938 |     Quit sc
 939 | ]]></Implementation>
 940 | </Method>
 941 | 
 942 | <Method name="ListItemsInFiles">
 943 | <ClassMethod>1</ClassMethod>
 944 | <FormalSpec><![CDATA[&itemList,&err]]></FormalSpec>
 945 | <ReturnType>%Status</ReturnType>
 946 | <Implementation><![CDATA[
 947 |     #define DoNotLoad 1
 948 |     set res = $system.OBJ.ImportDir(..TempFolder(),"*.xml","-d",.err,1, .itemList, $$$DoNotLoad)
 949 |     
 950 |     if '$Data(itemList) && $$$ISERR(res) {
 951 | 	    quit res
 952 |     }
 953 |     
 954 |     if $Get(err) > 0 {
 955 | 	    write "There were some errors while importing files",!
 956 | 	    for i=1:1:err {
 957 | 		    write err(i),!
 958 | 	    }
 959 |     }
 960 |     
 961 |     //change all csp/ names to /csp/ names
 962 |     #dim item As %String = "csp"
 963 |     for  {
 964 |         set item = $Order(itemList(item))
 965 |         quit:item=""
 966 |         quit:$Extract(item, 1, 4)'="csp/"
 967 |         kill itemList(item)
 968 |         set itemList("/"_item)=""
 969 |     }
 970 |     quit $$$OK
 971 | ]]></Implementation>
 972 | </Method>
 973 | 
 974 | <Method name="ImportRoutines">
 975 | <ClassMethod>1</ClassMethod>
 976 | <FormalSpec>force:%Boolean=0</FormalSpec>
 977 | <ReturnType>%Status</ReturnType>
 978 | <Implementation><![CDATA[
 979 | 	write "==import start==", !
 980 | 	
 981 |     #dim err, itemList
 982 |     
 983 |     kill err, itemList
 984 |     set err = 0   
 985 |     
 986 |     #dim ec As %Status = ..ListItemsInFiles(.itemList, .err)
 987 |     quit:'ec ec
 988 |     
 989 |     #dim internalName As %String = ""
 990 |     for  {
 991 |         set internalName = $Order(itemList(internalName))
 992 |         quit:internalName=""
 993 |         if '..IsInSourceControl(internalName) {
 994 |         	//w "item ",internalName," is not in source control, skipping",!
 995 |         	continue
 996 |         }
 997 |         #dim sc As %Status = ..ImportItem(internalName, force)
 998 |         if $$$ISERR(sc) {
 999 |             set ec = $$$ADDSC(ec, sc)
1000 |         }
1001 |     }
1002 |     
1003 |     //let's delete all items for which corresponding files had been deleted
1004 |     #dim item as %String = ""
1005 |     for  {
1006 |         set item = $Order(@..#Storage@("TSH", item))
1007 |         quit:item=""
1008 | 
1009 |         if '##class(%File).Exists(..FullExternalName(item)) {
1010 |             #dim type As %String = ..Type(item)
1011 |             #dim name As %String = ..NameWithoutExtension(item)
1012 |             #dim deleted As %Boolean = 1
1013 |             if type = "prj" {
1014 |                 set ec = $$$ADDSC(ec, $system.OBJ.DeleteProject(name))
1015 |             }elseif type = "cls" {
1016 |                 set ec = $$$ADDSC(ec, $system.OBJ.Delete(item))
1017 |             }elseif $ListFind($ListBuild("mac","int","inc","bas","mvb","mvi","dfi"), type) > 0 {
1018 |                 set ec = $$$ADDSC(ec, ##class(%Routine).Delete(item))
1019 |             }elseif type = "csp" {
1020 |                 #dim filename = $system.CSP.GetFileName(item)
1021 |                 if ##class(%File).Exists(filename) && '##class(%File).Delete(filename) {
1022 |                     set ec = $$$ADDSC(ec, ..MakeError("Error while removing "_item))
1023 |                 }
1024 |             } else {
1025 |                 set deleted = 0
1026 |             }
1027 |             
1028 |             if deleted && ec {
1029 |                 do ..RemoveRoutineTSH(item)
1030 |                 write item, " was deleted", !
1031 |             } else {
1032 | 	            if +$system.Status.GetErrorCodes(ec) '= $$$ClassDoesNotExist {
1033 |                 	write "Error: could not delete ", item, !
1034 | 	            } else {
1035 | 		            // if something we wanted to delete is already deleted -- good!
1036 | 		            set ec = $$$OK
1037 | 	            }
1038 |             }
1039 |         }
1040 |     }
1041 |     
1042 |     write "==import done==", !
1043 |     quit ec
1044 | ]]></Implementation>
1045 | </Method>
1046 | 
1047 | <Method name="ExportRoutinesAux">
1048 | <ClassMethod>1</ClassMethod>
1049 | <FormalSpec>path:%String,sep:%String="",level:%Integer=0,force:%Boolean=0</FormalSpec>
1050 | <ReturnType>%Status</ReturnType>
1051 | <Implementation><![CDATA[
1052 |     #define Dir
1053 |     #define OrderBy
1054 |     #define SystemFiles
1055 |     #define Flat
1056 |     #define NotStudio
1057 |     #define ShowGenerated 0
1058 |     #define Filter
1059 |     #define CspFile 5
1060 |     #define Directory 9
1061 |     #define CSPFolder 10
1062 |     
1063 |     #dim rs As %ResultSet = ##class(%ResultSet).%New("%RoutineMgr:StudioOpenDialog")
1064 |     #dim ec As %Status = rs.Execute(path_$case(path,"":"",:"/")_"*",$$$Dir, $$$OrderBy, $$$SystemFiles, $$$Flat, $$$NotStudio, $$$ShowGenerated, $$$Filter)
1065 |     quit:'ec ec
1066 |     while rs.Next() {
1067 |         #dim name As %String = rs.Get("Name")
1068 |         #dim isdirectory As %String = rs.Get("IsDirectory")
1069 |         #dim type As %String = rs.Get("Type")
1070 |         
1071 |         if (type = $$$Directory) || (type = $$$CSPFolder) {
1072 |             #dim newpath As %String = $case(path,"":name,:path_isdirectory_name)
1073 |             do ..ExportRoutinesAux(newpath, isdirectory, level + 1, force)
1074 |         } else {
1075 |             #dim InternalName As %String = path_sep_name
1076 |             if (type = $$$CspFile) && ($Extract(InternalName) '= "/") {
1077 |                 set InternalName = "/"_InternalName
1078 |             }
1079 |             set ec = ..ExportItem(InternalName, 1, force)
1080 |         }
1081 |     }
1082 |     kill rs
1083 |     quit ec
1084 | ]]></Implementation>
1085 | </Method>
1086 | 
1087 | <Method name="ExportItem">
1088 | <ClassMethod>1</ClassMethod>
1089 | <FormalSpec>InternalName:%String,expand:%Boolean=1,force:%Boolean=0</FormalSpec>
1090 | <ReturnType>%Status</ReturnType>
1091 | <Implementation><![CDATA[
1092 |     #dim type = ..Type(InternalName)
1093 |     //write "checking if we should export "_InternalName,!
1094 |     if type = "pkg" {
1095 |         $$$QuitOnError(..ExportRoutinesAux(..NameWithoutExtension(InternalName), ".", 0, force))
1096 |     }elseif type = "prj" && expand {
1097 |         $$$QuitOnError(..ExportProject(..NameWithoutExtension(InternalName), force))
1098 |         $$$QuitOnError(..ExportItem(InternalName, 0, force))
1099 |     }elseif (type = "csp") && ..IsCspFolder(InternalName) {
1100 |         $$$QuitOnError(..ExportRoutinesAux(InternalName , "/", 0, force))
1101 |     }else {
1102 |         if ..IsTempFileOutdated(InternalName) || force {
1103 |             
1104 |             #dim filename As %String = ..FullExternalName(InternalName)
1105 |             write "exporting new version of ", InternalName, " to ", filename,!
1106 |             $$$QuitOnError($system.OBJ.Export(InternalName, filename,"-d/diff"))
1107 |             $$$QuitOnError(..UpdateRoutineTSH(InternalName, $Horolog))
1108 |         } else {
1109 | 	        write !,InternalName, " is not newer than on-disk version, skipping export"
1110 |         }
1111 |     }
1112 |     quit $$$OK
1113 | ]]></Implementation>
1114 | </Method>
1115 | 
1116 | <Method name="ExportProject">
1117 | <ClassMethod>1</ClassMethod>
1118 | <FormalSpec>project:%String,force:%Boolean=0</FormalSpec>
1119 | <ReturnType>%Status</ReturnType>
1120 | <Implementation><![CDATA[
1121 |     #dim rs As %ResultSet = ##class(%ResultSet).%New("%Studio.Project:ProjectItemsList")
1122 |     $$$QuitOnError(rs.Execute(project))
1123 |     #dim typesWithoutExtension As %List = $ListBuild("CLS", "PKG")
1124 |     while rs.Next() {
1125 |         #dim name = rs.Get("Name")
1126 |         if $ListFind(typesWithoutExtension, rs.Get("Type")) {
1127 |             set name = name _ "." _ rs.Get("Type")
1128 |         }
1129 |         #dim ec As %Status = ..ExportItem(name, 1, force)
1130 |         quit:'ec
1131 |     }
1132 |     kill rs
1133 |     quit $$$OK
1134 | ]]></Implementation>
1135 | </Method>
1136 | 
1137 | <Method name="ExportAll">
1138 | <Description><![CDATA[
1139 | if <var>force</var> = 1 then we export item even if timestamp in system is older]]></Description>
1140 | <ClassMethod>1</ClassMethod>
1141 | <FormalSpec>force:%Boolean=0</FormalSpec>
1142 | <ReturnType>%Status</ReturnType>
1143 | <Implementation><![CDATA[
1144 |     $$$QuitOnError(..ExportRoutines(force))
1145 |     quit ..ExportSCList()
1146 | ]]></Implementation>
1147 | </Method>
1148 | 
1149 | <Method name="ImportAll">
1150 | <Description><![CDATA[
1151 | if <var>force</var> = 1 then we import item even if timestamp in system is newer]]></Description>
1152 | <ClassMethod>1</ClassMethod>
1153 | <FormalSpec>force:%Boolean=0</FormalSpec>
1154 | <ReturnType>%Status</ReturnType>
1155 | <Implementation><![CDATA[
1156 |     $$$QuitOnError(..ImportSCList())
1157 |     quit ..ImportRoutines(force)
1158 | ]]></Implementation>
1159 | </Method>
1160 | 
1161 | <Method name="ExportRoutines">
1162 | <ClassMethod>1</ClassMethod>
1163 | <FormalSpec>force:%Boolean=0</FormalSpec>
1164 | <ReturnType>%Status</ReturnType>
1165 | <Implementation><![CDATA[
1166 |     #dim item As %String = ""
1167 |     #dim ec As %Status = $$$OK
1168 |     for  {
1169 |         set item = $Order(@..#Storage@("items",item))
1170 |         quit:item=""
1171 |         set ec = ..ExportItem(item, 1, force)
1172 |         quit:'ec       
1173 |     }
1174 |     quit ec
1175 | ]]></Implementation>
1176 | </Method>
1177 | 
1178 | <Method name="ExportSCList">
1179 | <ClassMethod>1</ClassMethod>
1180 | <ReturnType>%Status</ReturnType>
1181 | <Implementation><![CDATA[
1182 |     #dim filename = ..TempFolder()_..#SCListFilename    
1183 |     #dim file As %File = ##class(%File).%New(filename)
1184 |     #dim item As %String = ""
1185 |     #dim defaultCspApp As %String = $system.CSP.GetDefaultApp($znspace)
1186 |     $$$QuitOnError(file.Open("WSN"))
1187 |     
1188 |     for  {
1189 |         set item = $Order(@..#Storage@("items",item))
1190 |         quit:item=""
1191 |         #dim fixedItem As %String = item
1192 |         if $Extract(fixedItem, 1, $Length(defaultCspApp)) = defaultCspApp {
1193 |             set $Extract(fixedItem, 1, $Length(defaultCspApp)) = "<cspapp>"
1194 |         }
1195 |         
1196 |         do file.WriteLine(fixedItem)
1197 |         
1198 |     }
1199 |     $$$QuitOnError(file.%Save())
1200 |     do file.Close()
1201 |     kill file
1202 |     quit $$$OK
1203 | ]]></Implementation>
1204 | </Method>
1205 | 
1206 | <Method name="ImportSCList">
1207 | <ClassMethod>1</ClassMethod>
1208 | <ReturnType>%Status</ReturnType>
1209 | <Implementation><![CDATA[
1210 |     #dim filename = ..TempFolder()_..#SCListFilename
1211 |     #dim file As %File = ##class(%File).%New(filename)
1212 |     #dim defaultCspApp As %String = $system.CSP.GetDefaultApp($znspace)
1213 |     #dim eol As %Boolean
1214 |     
1215 |     $$$QuitOnError(file.Open("R", 10))
1216 |     
1217 |     #dim a 
1218 |     while 'file.AtEnd  {
1219 |         #dim s As %String = file.ReadLine(,,.eol)
1220 |         continue:s=""
1221 |         #dim item As %String = $Replace(s, "<cspapp>", defaultCspApp)
1222 |         set a(..NormalizeExtension(item)) = ""
1223 |     }
1224 |     kill @..#Storage("items")
1225 |     merge @..#Storage("items") = a
1226 |     do file.Close()
1227 |     kill file
1228 |     quit $$$OK
1229 | ]]></Implementation>
1230 | </Method>
1231 | 
1232 | <Method name="RemoveFolderIfEmpty">
1233 | <Description>
1234 | returns true if directory was deleted</Description>
1235 | <ClassMethod>1</ClassMethod>
1236 | <FormalSpec>path:%String</FormalSpec>
1237 | <ReturnType>%Boolean</ReturnType>
1238 | <Implementation><![CDATA[
1239 |     #dim rs As %ResultSet = ##class(%ResultSet).%New("%File:FileSet")
1240 |     #define DirsFirst 1
1241 |     $$$QuitOnError(rs.Execute(path,,,$$$DirsFirst))
1242 |     #dim fileCount As %Integer = 0
1243 |     while rs.Next() {
1244 |         #dim fullname As %String = rs.Get("Name")
1245 |         #dim type As %String = rs.Get("Type")
1246 |         #dim name As %String = rs.Get("ItemName")
1247 |         #define IsDirectory(%type) %type="D"
1248 |         
1249 |         set fileCount = fileCount + 1
1250 |         quit:'$$$IsDirectory(type)
1251 |         continue:name=".git"
1252 |         if ..RemoveFolderIfEmpty(fullname) {
1253 |             set fileCount = fileCount - 1
1254 |         }
1255 |     }
1256 |     if fileCount = 0 {
1257 |         do ##class(%File).RemoveDirectory(path)
1258 |     }
1259 |     kill rs
1260 |     quit 'fileCount
1261 | ]]></Implementation>
1262 | </Method>
1263 | </Class>
1264 | </Export>
1265 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Alexander Koblov
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Caché Git 
  2 | 
  3 | Source Version Control plug-in for Caché Studio. Caché Git allows working with git-repos straight from Caché Studio.
  4 | 
  5 | ## Features
  6 | Caché Git provides interface from Caché Studio to TortoiseGit. Caché Git supports one repository for each Caché namespace. User chooses files to include in version control.
  7 | 
  8 | ## Pre-installation Requirements
  9 | 1. Install [msysgit](http://msysgit.github.com/). Choose "Run Git from the Windows Command Prompt" option when installing.
 10 | 1. Install [TorgoiseGit](http://code.google.com/p/tortoisegit/).
 11 | 
 12 | Caché Studio before 2011.1 cannot work with executables that have space in its name (like "C:\Program Files\TortoiseGit\bin\TortoiseGitProc.exe"). In that case you should either install TortoiseGit in the folder without spaces or use newer version of Caché Studio. Caché Studio can work with previous version of Caché server. For example, Caché Studio 2013.1 [can](http://docs.intersystems.com/cache_latest/csp/docbook/DocBook.UI.Page.cls?KEY=ISP_interop) work with Caché 2009.
 13 | 
 14 | _On *Nix systems Caché Git provides only Export/Import without calling TortoiseGit._
 15 | 
 16 | ## Installation in Caché:
 17 | 1. Enable [write-access](http://docs.intersystems.com/ens20151/csp/docbook/DocBook.UI.Page.cls?KEY=GSA_config#GSA_config_database_edit) to CACHELIB database via the Management Portal. (This is required for csp-page with settings import.)
 18 | 1. Import project in %SYS:
 19 | 
 20 |     %SYS>do $system.OBJ.ImportDir("c:\your-path-that-contains-project-downloaded-from-github","*.xml","ck",,1)
 21 | 
 22 | 1. Now you can disable write-access to CACHELIB.
 23 | 1. In Management Portal select the new %SourceControl.Git class as the desired Source Control class in all namespaces where you wish to use it. (System Administration >> Configuration >> Additional Settings >> Source Control)
 24 | 
 25 | ## Setup
 26 | In Studio, in any namespace with %SourceControl.Git as a Version Control Class choose menu "Git > Settings"
 27 | 
 28 | 1. Enter full path to TortoiseGitProc.exe (usually "C:\Program Files\TortoiseGit\bin\TortoiseGitProc.exe")
 29 | 1. Enter default temp folder (usually "C:\Temp"). ATTENTION! This folder shouldn't contain anything valuable. There will be subfolders for each Caché  namespace.
 30 | 1. You can also specify temp folder for this particular namespace. Otherwise temp folder for this namespace will be &lt;default-temp-folder>\\&lt;namespace>
 31 | 
 32 |   * If you don't want to enter you credentials every time you use git create in temp folder file _netrc and add string `machine your-git-server login your-git-login password your-git-password`.
 33 | Instead of your-git-server, your-git-login and your-git-password write actual values. Or use [Git Credentials](http://stackoverflow.com/a/15351702).
 34 | 
 35 | 
 36 | ## How to work with plug-in
 37 | ### How to start
 38 | 1. In Studio, select Git >> Tortoise Git Settings and set up options for Git (e.g. Proxy). This options are stored in folder that you chose as temp.
 39 | 1. Choose Git >> Create Repo. Press OK, one more time.
 40 | 1. You will notice that the Git menu now has a full set of options.
 41 | 1. A new menu item appears in context menu — "Git -> Add to Source Control", when right-clicking on elements in the Workspace Window (Alt+3).
 42 | 1. Choose elements you want to add to Git. These programs, classes, csp-pages etc. are exported to hdd-folder and automatically synchronized with it every time when you open or save them in Studio.
 43 | 1. Choose menu Commit.
 44 | 1. Select all files, right-click on them and choose "Add".
 45 | 1. Write comment and press "Commit".
 46 | 1. Now you can immediately push changes to server.
 47 |   * You should press Push
 48 |   * Then click Manage button and specify git-server
 49 |   * For example:
 50 |   * Remote: assembla
 51 |   * URL: http://git.assembla.com/demobld.git
 52 |   * Choose the server you have just specified.
 53 |   * Press OK
 54 | 
 55 | ### How to join existing repository
 56 | 1. Choose menu Clone.
 57 | 1. Enter repository URL.
 58 | 1. [If your TortoiseGit Version < 1.8.5] In appeared window TortoiseGit adds repository name to folder. You should delete it (Write c:\temp\git\user instead of c:\temp\git\user\reponame)
 59 | 1. Press 'OK'.
 60 | 1. Select menu Import All to load changes from temp folder to Caché. Import All compares timestamps of files and Caché items and import files only if they are newer then Caché versions. There is also Import All Force menu item that import files without any checks.
 61 | 
 62 | ### Work Cycle
 63 | 1. Choose menu item Pull.
 64 | 1. Resolve conflicts in TortoiseGit if any.
 65 | 1. Select menu Import All to load changes from temp folder to Caché.
 66 | 1. Do some changes in Caché Studio.
 67 | 1. [Optional] Select menu Export All if you want to force-unload changes to temp folder from Caché.
 68 | 1. Select Commit
 69 | 1. Select Push from Caché Studio menu or immediately after Commit.
 70 | 
 71 | ### Global's structure
 72 | Data used by Caché-Git is stored in global which name is defined by Storage parameter of %SourceControl.Git.Utils class. Its value by default — ^Git.
 73 | Options (path to tortoiseproc.exe and temp folder) are stored in %SYS namespace in nodes ^Git("%gitBinPath") and ^Git("%defaultTemp").
 74 | In each namespace we also store path to temp folder for this namespace that can override default path. Global name is ^Git("settings","namespaceTemp")
 75 | 
 76 | In ^Git("items") node namespace elements are stored that traced by Caché-Git. We store names of particular items with extension in lower-case.
 77 | 
 78 | In ^Git("TSH") node timestamps of last synchronization for each routine are stored.
 79 | 
 80 | To run all tests:
 81 |     
 82 | 	%SYS>do ##class(%SourceControl.Git.Test.Git).runall()
 83 | 	
 84 | ### Extra Repository Settings
 85 | #### Mappings
 86 | To specify particular folder in repository where Caché Git should place files set value of `^Git("settings","mappings") to relative path. Additionally you can specify subfolder for each particular item type.
 87 | 
 88 | For example:
 89 | 
 90 | 	USER>zwrite ^Git
 91 | 	^Git("settings","mappings")="src/cache/"
 92 | 	^Git("settings","mappings","cls")="cls/"
 93 | 	^Git("settings","mappings","csp")="csp-data/"
 94 | 	^Git("settings","mappings","dfi")="dfi/"
 95 | 	^Git("settings","mappings","mac")="mac/"
 96 | 	^Git("settings","namespaceTemp")="C:\temp\testctg\"
 97 | 	
 98 | In this particular case Caché Git stores all its files (except sc-list.txt) in `src/cache/` subfolder. Classes are stored in `src/cache/cls/` etc. All csp files (including static files -- js, css) are stored in `src/cache/csp-data/`. With this particular path to repository classes will be stored in folder `C:\temp\testctg\src\cache\cls\`.
 99 | 
100 | You can omit root mappings. Mappings for particular item type are still applied.
101 | 
102 | #### Other Settings
103 | The following sub-nodes of `^Git("settings")` allow for further configuration:
104 | 
105 | * `"groupByFolder"` - boolean value that defaults to `0` when not specified. The setting applies to all INC, MAC and INT routines as well as DFI exports.
106 |   * When this value is true, use nested folders for these files, e.g. `Package.Include.INC` would be exported to `<rootfolder>/Package/Include.inc.xml`
107 |   * When this value is false, all these files are exported to the root folder, e.g. `Package.Include.INC` would be exported to `<rootfolder>/Package.Include.inc.xml`
108 | * `"includeExtensionInFilename"` - boolean value that defaults to `1` when not specified.
109 |   * When true, exported files include the lowercase extension in the filename, e.g. `MyClass.cls.xml`
110 |   * When false, exported files do not include the extension in the filename, e.g. `MyClass.xml`
111 | 
112 | NOTE: Caché Git does not do any automatic moving of files. If you have classes placed in root folder and change mappings for cls to "src/cache/cls/" you need to move files corresponding to these classes manually. Better -- set mappings on creating of repository, before adding new items to source control.
113 | 


--------------------------------------------------------------------------------
/cache-tort-git.prj.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <Export generator="Cache" version="25">
 3 | <Project name="cache-tort-git" LastModified="2016-07-31 23:57:25.117897" HttpServer="http://localhost:57780">
 4 |   <Items>
 5 |     <ProjectItem name="%SourceControl" type="PKG"></ProjectItem>
 6 |     <ProjectItem name="csp/sys/gitprojectsettings.csp" type="CSP"></ProjectItem>
 7 |   </Items>
 8 | </Project>
 9 | </Export>
10 | 


--------------------------------------------------------------------------------
/csp/gitprojectsettings.csp.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <Export generator="Cache" version="25">
 3 | <CSP name="gitprojectsettings.csp" application="/csp/sys/" default="1"><![CDATA[
 4 | <html>
 5 | <head>
 6 | <title>Cache-Git Settings</title></head>
 7 | <STYLE type='text/css'>
 8 | .error {
 9 |     color: red;
10 | }
11 | </STYLE>
12 | <body>
13 | <server>
14 |  set namespace = %request.Data("NSpace",1)
15 |  set oldNS=$znspace
16 |  znspace namespace
17 |  if $Data(%request.Data("gitsettings",1)) {
18 |      kill settings
19 |      for param="gitBinPath","defaultTemp","namespaceTemp","groupByFolder" {
20 |          set settings(param) = $Get(%request.Data(param,1))
21 |      } 
22 |      do ##class(%SourceControl.Git.Utils).UpdateSettings(.settings)
23 |  }
24 |  set gitBinPath = ##class(%SourceControl.Git.Utils).GitBinPath()
25 |  set defaultTemp = ##class(%SourceControl.Git.Utils).DefaultTemp()
26 |  set namespaceTemp = ##class(%SourceControl.Git.Utils).TempFolder()
27 |  set groupByFolder = ##class(%SourceControl.Git.Utils).GroupByFolder()
28 |  znspace oldNS
29 |  set:defaultTemp="" defaultTemp =  "c:\temp\"
30 |  
31 | </server>
32 | <form method='post'>
33 | <input type="hidden" name="NSpace" value="#(..EscapeHTML(namespace))#" />
34 | <input type="hidden" name="gitsettings" value="1" />
35 | <h1>Settings</h1>
36 | <table>
37 | <csp:if condition='$system.Version.GetOS()="Windows"'>
38 | <tr>
39 | <td>Path to tortoisegitproc.exe<br/>(e.g. c:\tortoisegit\bin\tortoisegitproc.exe)</td><td><input type="text" name="gitBinPath" size=40 value='#(..EscapeHTML(gitBinPath))#'/></td>
40 | </tr>
41 | 
42 | <csp:if condition='$D(%request.Data("gitsettings",1)) && (##class(%SourceControl.Git.Utils).GitBinExists()=0)'>
43 | <tr><td colspan='2' align=center class='error'>
44 | file does not found
45 | </td></tr>
46 | </csp:if>
47 | 
48 | </csp:if>
49 | <tr>
50 | <td>Default path to temp folder<br/>(e.g. c:\temp)</td><td><input type="text" name="defaultTemp" size=40 value='#(..EscapeHTML(defaultTemp))#'/></td>
51 | </tr>
52 | <tr><th colspan="2">Settings for this namespace only</th>
53 | </tr>
54 | <tr>
55 | <td>Temp folder for this namespace<br/>(e.g. c:\someproj\)</td><td><input type="text" name="namespaceTemp" size=40 value='#(..EscapeHTML(namespaceTemp))#'/></td>
56 | </tr>
57 | <!--
58 | <tr>
59 | <td>Group all items by folders</td><td><input type="checkbox" name="groupByFolder" size=40 #($case(groupByFolder,1:"checked",:""))#/></td>
60 | </tr>
61 | -->
62 | </table>
63 | <input type='submit' value = 'Save!'/>
64 | </form>
65 | <csp:if condition='$D(%request.Data("gitsettings",1)) && (##class(%SourceControl.Git.Utils).NeedSettings() = 0)'>
66 |     <em>Click cross in the upper-right corner to close the settings window.</em>
67 | </csp:if>
68 | </body>
69 | </html>]]></CSP>
70 | </Export>
71 | 


--------------------------------------------------------------------------------
/sc-list.txt:
--------------------------------------------------------------------------------
1 | %SourceControl.pkg
2 | <cspapp>/gitprojectsettings.csp
3 | cache-tort-git.prj
4 | 


--------------------------------------------------------------------------------