@@ -1,12 +1,7 @@
 module U.Util.String where
 
-import Data.Maybe (fromMaybe)
-import Safe.Foldable (minimumMay)
+import qualified Data.Text as Text
+import qualified U.Util.Text as Text
 
 stripMargin :: String -> String
-stripMargin str =
-  let stripLen =
-        fromMaybe 0 . minimumMay
-          . map (length . fst . span (== ' '))
-          $ lines str
-   in unlines . map (drop stripLen) $ lines str
+stripMargin = Text.unpack . Text.stripMargin . Text.pack
@@ -1,13 +1,15 @@
+{-# LANGUAGE BlockArguments #-}
+{-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE QuasiQuotes #-}
 
 module U.Util.Text where
 
+import qualified Data.Char as Char
 import Data.Maybe (fromMaybe)
 import Data.Text (Text)
 import qualified Data.Text as Text
 import Safe.Foldable (minimumMay)
-import Debug.Trace (trace, traceShowId)
 
 -- | remove however many spaces prefix all of the lines of the input
 -- e.g.
@@ -22,25 +24,15 @@ stripMargin :: Text -> Text
 stripMargin str =
   let stripLen =
         Data.Maybe.fromMaybe 0 . minimumMay
-          . map (Text.length . fst)
-          . filter (not . Text.null . snd)
-          . map (Text.span (== ' '))
-          . filter (not . Text.null)
+          . map (Text.length . fst . Text.span (== ' '))
+          . filter (not . Text.all (Char.isSpace))
           $ Text.lines str
-  in Text.unlines . traceShowId. map (Text.drop $ traceShowId stripLen) $ traceShowId $ Text.lines str
-
-test :: Bool
-test =
-  stripMargin x
-     == y
-
-x' :: Text
-x' = stripMargin x
-x :: Text
-x = "          def foo:" <> "\n" <>
-    "            blah blah" <> "\n" <>
-    "      "
-
-y :: Text
-y = "def foo:" <> "\n" <>
-    "  blah blah" <> "\n"
+      dropFirstIf f = \case
+        h : t | f h -> t
+        x -> x
+      dropLastIf f = reverse . dropFirstIf f . reverse
+   in Text.unlines
+        . dropLastIf Text.null
+        . dropFirstIf Text.null
+        . map (Text.drop stripLen)
+        $ Text.lines str
@@ -69,7 +69,7 @@ test rt = tests
   , Typechecker.test
   , UriParser.test
   , Context.test
-  -- , Git.test
+  , Git.test
   , Upgrade12.test
   , GitSimple.test
   , TestIO.test
 
@@ -4,7 +4,7 @@
 
 module Unison.Test.Codebase.Upgrade12 (test) where
 
-import Data.String.Here.Interpolated (iTrim)
+import Data.String.Here.Interpolated (i)
 import EasyTest (Test, scope, tests, io, ok)
 import Shellmet ()
 import qualified Unison.Test.Ucm as Ucm
@@ -18,102 +18,102 @@ typeAlias :: Test ()
 typeAlias = scope "typeAlias" do
   void $ io do
     c1 <- Ucm.initCodebase Ucm.CodebaseFormat1
-    Ucm.runTranscript c1 Ucm.Runtime1 [iTrim|
-```ucm
-.> alias.type ##Nat builtin.Nat
-```
+    Ucm.runTranscript c1 Ucm.Runtime1 [i|
+        ```ucm
+        .> alias.type ##Nat builtin.Nat
+        ```
       |]
     c2 <- Ucm.upgradeCodebase c1
-    Ucm.runTranscript c2 Ucm.Runtime1 [iTrim|
-```unison
-x : Nat
-x = 3
-```
+    Ucm.runTranscript c2 Ucm.Runtime1 [i|
+      ```unison
+      x : Nat
+      x = 3
+      ```
     |]
   ok
 
 topLevelTerm :: Test ()
 topLevelTerm = scope "topLevelTerm" $ do
   void $ io do
     c1 <- Ucm.initCodebase Ucm.CodebaseFormat1
-    Ucm.runTranscript c1 Ucm.Runtime1 [iTrim|
-```unison:hide
-y = 3
-```
-```ucm
-.> add
-```
+    Ucm.runTranscript c1 Ucm.Runtime1 [i|
+        ```unison:hide
+        y = 3
+        ```
+        ```ucm
+        .> add
+        ```
       |]
     c2 <- Ucm.upgradeCodebase c1
-    Ucm.runTranscript c2 Ucm.Runtime1 [iTrim|
-```ucm
-.> find
-```
-```unison
-> y
-```
+    Ucm.runTranscript c2 Ucm.Runtime1 [i|
+      ```ucm
+      .> find
+      ```
+      ```unison
+      > y
+      ```
     |]
   ok
 
 subNamespace :: Test ()
 subNamespace = scope "subNamespace" do
   void $ io do
     c1 <- Ucm.initCodebase Ucm.CodebaseFormat1
-    Ucm.runTranscript c1 Ucm.Runtime1 [iTrim|
-```ucm
-.> alias.type ##Nat builtin.Nat
-```
-```unison
-unique type a.b.C = C Nat
-```
-```ucm
-.> add
-```
+    Ucm.runTranscript c1 Ucm.Runtime1 [i|
+        ```ucm
+        .> alias.type ##Nat builtin.Nat
+        ```
+        ```unison
+        unique type a.b.C = C Nat
+        ```
+        ```ucm
+        .> add
+        ```
       |]
     c2 <- Ucm.upgradeCodebase c1
-    Ucm.runTranscript c2 Ucm.Runtime1 [iTrim|
-```ucm
-.> find
-```
-```unison
-> a.b.C.C 3
-```
+    Ucm.runTranscript c2 Ucm.Runtime1 [i|
+      ```ucm
+      .> find
+      ```
+      ```unison
+      > a.b.C.C 3
+      ```
     |]
   ok
 
 accessPatch :: Test ()
 accessPatch = scope "accessPatch" do
   void $ io do
     c1 <- Ucm.initCodebase Ucm.CodebaseFormat1
-    Ucm.runTranscript c1 Ucm.Runtime1 [iTrim|
-```ucm
-.> alias.type ##Nat builtin.Nat
-```
-```unison:hide
-unique type A = A Nat
-foo = A.A 3
-```
-```ucm
-.> debug.file
-.> add
-```
-```unison:hide
-unique type A = A Nat Nat
-foo = A.A 3 3
-```
-```ucm
-.> debug.file
-.> update
-```
-```ucm
-.> view.patch patch
-```
+    Ucm.runTranscript c1 Ucm.Runtime1 [i|
+        ```ucm
+        .> alias.type ##Nat builtin.Nat
+        ```
+        ```unison:hide
+        unique type A = A Nat
+        foo = A.A 3
+        ```
+        ```ucm
+        .> debug.file
+        .> add
+        ```
+        ```unison:hide
+        unique type A = A Nat Nat
+        foo = A.A 3 3
+        ```
+        ```ucm
+        .> debug.file
+        .> update
+        ```
+        ```ucm
+        .> view.patch patch
+        ```
       |]
     c2 <- Ucm.upgradeCodebase c1
-    Ucm.runTranscript c2 Ucm.Runtime1 [iTrim|
-```ucm
-.> view.patch patch
-```
+    Ucm.runTranscript c2 Ucm.Runtime1 [i|
+      ```ucm
+      .> view.patch patch
+      ```
     |]
   ok
 
@@ -126,27 +126,27 @@ accessHistory :: Test ()
 accessHistory = scope "history" do
   void $ io do
     c1 <- Ucm.initCodebase Ucm.CodebaseFormat1
-    Ucm.runTranscript c1 Ucm.Runtime1 [iTrim|
-```unison
-foo = 3
-```
-```ucm
-.> add
-```
-```unison
-foo = 4
-```
-```ucm
-.> update
-.> history
-```
+    Ucm.runTranscript c1 Ucm.Runtime1 [i|
+        ```unison
+        foo = 3
+        ```
+        ```ucm
+        .> add
+        ```
+        ```unison
+        foo = 4
+        ```
+        ```ucm
+        .> update
+        .> history
+        ```
       |]
     c2 <- Ucm.upgradeCodebase c1
-    Ucm.runTranscript c2 Ucm.Runtime1 [iTrim|
-```ucm
-.> history
-.> reset-root #ls8
-.> history
-```
-    |]
+    Ucm.runTranscript c2 Ucm.Runtime1 [i|
+        ```ucm
+        .> history
+        .> reset-root #ls8
+        .> history
+        ```
+      |]
   ok