Enable comment suppression in generated nix code

Author: sd234678

.last-exported-commit

@@ -1 +1 @@
-Last exported commit from parent repo: 8c0dabbabd903d9c05f2745af87ec86f6f413791
+Last exported commit from parent repo: b4a296093f5e7ee90367d58a20e8c4c67d8f7e64

nix-bootstrap.cabal

@@ -5,7 +5,7 @@ cabal-version: 2.0
 -- see: https://github.com/sol/hpack
 
 name:           nix-bootstrap
-version:        1.4.0.0
+version:        1.4.1.0
 author:         gchquser
 maintainer:     [email protected]
 copyright:      Crown Copyright

package.yaml

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 name: nix-bootstrap
-version: 1.4.0.0
+version: 1.4.1.0
 author: gchquser
 maintainer: [email protected]
 copyright: Crown Copyright

src/Bootstrap/Data/Bootstrappable.hs

@@ -22,7 +22,8 @@ module Bootstrap.Data.Bootstrappable
 where
 
 import Bootstrap.Nix.Expr
-  ( Identifier (unIdentifier),
+  ( CommentsPolicy (ShowComments),
+    Identifier (unIdentifier),
     IsNixExpr (toNixExpr),
     isMostlyCorrectlyScoped,
     writeExprFormatted,
@@ -146,7 +147,7 @@ bootstrapContentNix a = do
             ( ("Could not format nix expression: " <>)
                 . displayException
             )
-            <$> writeExprFormatted expr
+            <$> writeExprFormatted ShowComments expr
         Left (i1 :| iRest) ->
           pure . Left $
             "Nix expression is incorrectly scoped; it references the out of scope "

src/Bootstrap/Nix/Expr.hs

@@ -61,6 +61,7 @@ module Bootstrap.Nix.Expr
     writeExprForTerminal,
     -- | `writeBinding` writes out a `Binding` without formatting it.
     writeBinding,
+    CommentsPolicy (..),
 
     -- * Validation
 
@@ -109,7 +110,6 @@ import Text.Megaparsec
   )
 import Text.Megaparsec.Char (alphaNumChar, char, letterChar, space, space1, string)
 import qualified Text.Megaparsec.Char.Lexer as L
-import Text.Regex (mkRegex, subRegex)
 
 type Parser = Parsec Void Text
 
@@ -178,31 +178,34 @@ infixl 7 |++
 (|++) :: Expr -> Expr -> Expr
 (|++) e1 = (e1 |* EListConcatOperator |*)
 
+-- | Whether to include comments when formatting
+data CommentsPolicy = ShowComments | HideComments
+
 -- | Writes out an `Expr` as Nix code
-writeExpr :: Expr -> Text
-writeExpr =
+writeExpr :: CommentsPolicy -> Expr -> Text
+writeExpr cp =
   \case
-    EApplication e1 e2 -> writeExpr e1 <> " " <> writeExpr e2
-    EFunc args e -> writeFunctionArgs args <> writeExpr e
-    EGrouping e -> "(" <> writeExpr e <> ")"
+    EApplication e1 e2 -> writeExpr cp e1 <> " " <> writeExpr cp e2
+    EFunc args e -> writeFunctionArgs args <> writeExpr cp e
+    EGrouping e -> "(" <> writeExpr cp e <> ")"
     EIdent (Identifier i) -> i
     EImport -> "import"
-    ELetIn bindings e -> "let " <> sconcat (writeBinding <$> bindings) <> "in " <> writeExpr e
+    ELetIn bindings e -> "let " <> sconcat (writeBinding cp <$> bindings) <> "in " <> writeExpr cp e
     EList exprs ->
       "["
         <> (if length exprs > 2 then "\n" else "")
-        <> T.concat (intersperse " " (writeExpr <$> exprs))
+        <> T.concat (intersperse " " (writeExpr cp <$> exprs))
         <> "]"
     EListConcatOperator -> "++"
     ELit l -> writeLiteral l
-    EPropertyAccess e1 p -> writeExpr e1 <> "." <> writeProperty p
+    EPropertyAccess e1 p -> writeExpr cp e1 <> "." <> writeProperty cp p
     ESet isRec bindings ->
       (if isRec then "rec " else "")
         <> "{"
         <> (if length bindings > 2 then "\n" else " ")
-        <> mconcat (writeBinding <$> bindings)
+        <> mconcat (writeBinding cp <$> bindings)
         <> "}"
-    EWith additionalScope e -> "with " <> writeExpr additionalScope <> "; " <> writeExpr e
+    EWith additionalScope e -> "with " <> writeExpr cp additionalScope <> "; " <> writeExpr cp e
     . mergeNestedLetExprs
 
 -- | Recursively merges nested let expressions into a single let in block
@@ -236,19 +239,15 @@ mergeNestedLetExprs = \case
       PCons p1 p2 -> PCons (mergeNestedLetExprsP p1) (mergeNestedLetExprsP p2)
 
 -- | Writes out an `Expr` as Nix code, formatting it with alejandra
-writeExprFormatted :: MonadIO m => Expr -> m (Either IOException Text)
-writeExprFormatted = runExceptT . (fmap toText <$> alejandra . toString . writeExpr)
+writeExprFormatted :: MonadIO m => CommentsPolicy -> Expr -> m (Either IOException Text)
+writeExprFormatted cp = runExceptT . (fmap toText <$> alejandra . toString . writeExpr cp)
 
 -- | Like writeExpr, but strips out line comments,
 -- replaces whitespace groups with a single space,
 -- and escapes dollar symbols.
 writeExprForTerminal :: Expr -> Text
 writeExprForTerminal e =
-  unwords . words . toText $
-    subRegex
-      (mkRegex "\n#[^\n]*\n")
-      (toString . T.replace "$" "\\$" $ writeExpr e)
-      " "
+  unwords . words . T.replace "$" "\\$" $ writeExpr HideComments e
 
 -- | Runs `parseE`, parsing a Nix expression
 parseExpr :: Text -> Either Text Expr
@@ -386,12 +385,14 @@ infixr 4 |=
 (|=) = BNameValue
 
 -- | Writes out a `Binding` as Nix code
-writeBinding :: Binding -> Text
-writeBinding = \case
+writeBinding :: CommentsPolicy -> Binding -> Text
+writeBinding cp = \case
   BInherit xs -> "inherit " <> writeIdentifiers " " xs <> ";\n"
-  BInheritFrom from xs -> "inherit (" <> writeExpr from <> ") " <> writeIdentifiers " " xs <> ";\n"
-  BLineComment c -> "# " <> c <> "\n"
-  BNameValue p v -> writeProperty p <> " = " <> writeExpr v <> ";\n"
+  BInheritFrom from xs -> "inherit (" <> writeExpr cp from <> ") " <> writeIdentifiers " " xs <> ";\n"
+  BLineComment c -> case cp of
+    ShowComments -> "# " <> c <> "\n"
+    HideComments -> ""
+  BNameValue p v -> writeProperty cp p <> " = " <> writeExpr cp v <> ";\n"
   where
     writeIdentifiers :: Text -> NonEmpty Identifier -> Text
     writeIdentifiers sep = T.concat . intersperse sep . fmap unIdentifier . toList
@@ -605,11 +606,11 @@ parseProperty requireDot = do
         Nothing -> pure p
 
 -- | Writes out a `Property` as Nix code
-writeProperty :: Property -> Text
-writeProperty = \case
+writeProperty :: CommentsPolicy -> Property -> Text
+writeProperty cp = \case
   PIdent (Identifier i) -> i
-  PAntiquote e -> "${" <> writeExpr e <> "}"
-  PCons p1 p2 -> writeProperty p1 <> "." <> writeProperty p2
+  PAntiquote e -> "${" <> writeExpr cp e <> "}"
+  PCons p1 p2 -> writeProperty cp p1 <> "." <> writeProperty cp p2
 
 -- | Parses an `ESet`
 parseSet ::

src/Bootstrap/Nix/Expr/ReproducibleBuild/Go.hs

@@ -7,6 +7,7 @@ module Bootstrap.Nix.Expr.ReproducibleBuild.Go (reproducibleGoBuild) where
 import Bootstrap.Data.ProjectName (ProjectName (unProjectName))
 import Bootstrap.Nix.Expr
   ( Binding (BLineComment),
+    CommentsPolicy (ShowComments),
     Expr (ELit, ESet),
     Literal (LString),
     nix,
@@ -33,5 +34,5 @@ reproducibleGoBuild projectName =
         |],
         [nixbinding|# When the build fails, it will tell you what the expected hash is.
         |],
-        BLineComment (writeBinding [nixbinding|vendorSha256 = "sha256-00000000000000000000000000000000000000000000";|])
+        BLineComment (writeBinding ShowComments [nixbinding|vendorSha256 = "sha256-00000000000000000000000000000000000000000000";|])
       ]

src/Bootstrap/Nix/Flake.hs

@@ -16,7 +16,8 @@ import Bootstrap.GitPod (resetPermissionsInGitPod)
 import Bootstrap.Monad (MonadBootstrap)
 import Bootstrap.Nix.Evaluate (NixBinaryPaths, runNix)
 import Bootstrap.Nix.Expr
-  ( Expr (ELit, ESet),
+  ( CommentsPolicy (ShowComments),
+    Expr (ELit, ESet),
     Literal (LString),
     nixbinding,
     nixproperty,
@@ -53,7 +54,7 @@ writeIntermediateFlake projectName =
     . try @_ @IOException
     . writeFileText "flake.nix"
     . (<> "\n")
-    . writeExpr
+    . writeExpr ShowComments
     $ intermediateFlake projectName
 
 intermediateFlake :: ProjectName -> Expr

test/Bootstrap/Nix/ExprSpec.hs

@@ -9,6 +9,7 @@ module Bootstrap.Nix.ExprSpec (spec) where
 
 import Bootstrap.Nix.Expr
   ( Binding (BInherit, BInheritFrom, BLineComment, BNameValue),
+    CommentsPolicy (ShowComments),
     Expr
       ( EApplication,
         EFunc,
@@ -150,12 +151,12 @@ spec = do
     it "backtracks if an identifier begins with \"import\"" do
       parseExpr "imports" `shouldBe` Right (EIdent $ Identifier "imports")
     it "merges nested let-in expressions" do
-      parseExpr (writeExpr [nix|let x = 5; in let y = 4; in ""|])
+      parseExpr (writeExpr ShowComments [nix|let x = 5; in let y = 4; in ""|])
         `shouldBe` Right [nix|let x = 5; y = 4; in ""|]
     describe "EApplication" do
       it "roundtrips with multiple arguments" do
         let expr = EApplication (EApplication EImport (EIdent $ Identifier "nixpkgs")) (ESet False [])
-        parseExpr (writeExpr expr) `shouldBe` Right expr
+        parseExpr (writeExpr ShowComments expr) `shouldBe` Right expr
     describe "EPropertyAccess" do
       it "correctly parses a property access expression" do
         parseExpr "(let a = \"hello\"; b = \"world\"; in a).b"
@@ -289,7 +290,7 @@ spec = do
 
 -- | An expectation that a Nix expression is the same when written out and parsed again.
 roundtrips :: Expr -> Expectation
-roundtrips e = parseExpr (writeExpr e) `shouldBe` Right e
+roundtrips e = parseExpr (writeExpr ShowComments e) `shouldBe` Right e
 
 -- Arbitrary Helpers
 

test/Bootstrap/Nix/FlakeSpec.hs

@@ -4,7 +4,7 @@
 module Bootstrap.Nix.FlakeSpec (spec) where
 
 import Bootstrap.Data.ProjectName (mkProjectName)
-import Bootstrap.Nix.Expr (writeExprFormatted)
+import Bootstrap.Nix.Expr (CommentsPolicy (ShowComments), writeExprFormatted)
 import Bootstrap.Nix.Flake (intermediateFlake)
 import qualified Relude.Unsafe as Unsafe
 import Test.Hspec (Spec, describe, it)
@@ -14,7 +14,7 @@ import Text.RawString.QQ (r)
 spec :: Spec
 spec = describe "intermediateFlake" do
   it "correctly writes the intermediate flake" do
-    e <- writeExprFormatted (intermediateFlake $ Unsafe.fromJust $ mkProjectName "test-project")
+    e <- writeExprFormatted ShowComments (intermediateFlake $ Unsafe.fromJust $ mkProjectName "test-project")
     e
       `shouldBe` Right
         [r|{