Converting Wolfram Language Scripts (.wls) into PDFs

Question

I have just discovered the free (as in free beer) Wolfram Engine, coming with a generous licence. After playing with Mathematica for a while, and missing the notebook feature, I would like to generate a PDF out of the .wls scripts I am going to create.

In order to do this, I assume I have to create a notebook and subsequently exporting it to a PDF.

Consider the following foo.wls script:

(* = Title = *)

1 + 2 
{x + y, 1/x + 1/y}

(* = Plots = *)
Plot[x^2, {x, -10, 10}]

I can generate the PDF like follows:

(* Options suggested by https://mathematica.stackexchange.com/a/133058/95308 *)
SetOptions[First[$Output], FormatType -> StandardForm]; 

(* Import script as a list of deferred expressions *)
wls = Import[FileNameJoin[{$TemporaryDirectory, "foo.wls"}], "HeldExpressions"];
exprs = wls /. HoldComplete -> Defer;

(* Convert expressions into notebook cells *)
cells = Function[e, ExpressionCell[e, "Input"]] /@  exprs; 

(* This is for the eyes *)
cells = Join[{TextCell["Testing .wls Scripts", "Title"]}, cells];

UsingFrontEnd[

  (* Make the cells into an in-memory notebook *)
  nb = CreateDocument[cells];
  
  (* Evaluate input cells to add the related output *)
  NotebookEvaluate[nb, InsertResults -> True, EvaluationElements -> All];
  
  (* Save the notebook to a file and export it as a PDF *)
  NotebookSave[nb, FileNameJoin[{$TemporaryDirectory, "foo.nb"}]];
  Export[FileNameJoin[{$TemporaryDirectory, "foo.pdf"}], nb];
  NotebookClose[nb]
  
]

The result is not particularly bad, as per the picture below, but comments are gone.

This is due to Import[...foo.wls", "HeldExpressions"] above. I could use "Comments", instead, and get them. Still, I would not get their position with respect to expressions. Manually parsing the file would be possible only for expressions spanning over a single line, as there is no simple way to tell in which line a multiline expression ends.

What are your suggestions?

Answer 1

1. Load the script as text.
2. Replace all (* ... *) with cOmMeNt["..."], eventually with proper escaping.
3. Put text into a stream using StringToStream.
4. Import that.
5. Comments are available as expressions with the cOmMeNt head. The weird spelling is to make name clashes unlikely.
6. Wrap TextCell cells around the contents of the cOmMeNt expressions.
7. Generate the notebook as previously.

Answer 2

another method, use player :) :

take your code as an example:

comment can be TextCell with style.

Column[{
  (* = Title = *)
TextCell["Testing .wls Scripts", "Title"],
TextCell["1+2"],
1 + 2 ,
TextCell["{x + y, 1/x + 1/y}"],
{x + y, 1/x + 1/y},

(* = Plots = *)
TextCell["Plot[x^2, {x, -10, 10}],"],
Plot[x^2, {x, -10, 10}],

}]

You can use wolfram engine + Cell@BoxData@ToBoxes to create this cdf file.

My tool is https://github.com/asukaminato0721/mmaplayer/blob/master/server.wls

Answer 3

I found a solution using the low-level cell representation Cell[].

Using Jupyter front-end

This code works using the free (as in free-speech) Jupyter front-end with the Wolfram Mathematica plugin.

(* Options suggested by https://mathematica.stackexchange.com/a/133058/95308 *)
SetOptions[First[$Output], FormatType -> StandardForm]; 

(* Import script as a text string *)
text = Import[FileNameJoin[{$TemporaryDirectory, "foo.wls"}], "Text"];

UsingFrontEnd[

  (* Make the cells into an in-memory notebook *)
  nb = CreateDocument[{  
    (* This is for the eyes *)
    TextCell["Testing .wls Scripts", "Title"],
    Cell[text, "Input"]
    }];
      
  (* Evaluate input cells to add the related output *)
  NotebookEvaluate[nb, InsertResults -> True, EvaluationElements -> All];
  
  (* Save the notebook to a file and export it as a PDF *)
  NotebookSave[nb, FileNameJoin[{$TemporaryDirectory, "foo.nb"}]];
  Export[FileNameJoin[{$TemporaryDirectory, "foo.pdf"}], nb];
  NotebookClose[nb]
  
]

Here is the resulting PDF:

Using wolframscript (UPDATED)

When converted into an executable script, the code above presents a few issues. Essentially due to the fact that wolframscript exits too fast, before the evaluation is fully done. To fix this, I refactored the code, in order to wait for evaluation to be completed.

(* Check if the notebook is still evaluating *)
notebookEvaluatingQ[nb_] := Length[notebookEvaluatingCells[nb]] > 0

(* Get the currently evaluating cells in the notebook *)
notebookEvaluatingCells[nb_] := Select[Cells[nb], "Evaluating" /. Developer`CellInformation[#]&]

(* Pause until evaluation is finished *)
notebookPauseForEvaluation[nb_] := Module[{},  
  While[notebookEvaluatingQ[nb],
       Print["..."]
       Pause[0.25]]
]


(* Import script as a text string *)
text = Import[FileNameJoin[{$TemporaryDirectory, "foo.wls"}], "Text"];

UsingFrontEnd[

  (* Make the cells into an in-memory notebook *)
  nb = CreateDocument[{  
    (* This is for the eyes *)
    TextCell["Testing .wls Scripts", "Title"],
    Cell[text, "Input"]
    }];
  
  (* Select all cells and evaluate them *)
  SelectionMove[nb, All, Notebook]; 
  SelectionEvaluate[nb]; 

  (* Function to check if the notebook is still evaluating *)
  notebookPauseForEvaluation[nb]
    
  (* Save the notebook to a file and export it as a PDF *)
  NotebookSave[nb, FileNameJoin[{$TemporaryDirectory, "foo.nb"}]];
  Export[FileNameJoin[{$TemporaryDirectory, "foo.pdf"}], nb];
  NotebookClose[nb]
 
]

If you save the code as export.wls, you can execute it with:

wolframscript -f export.wls

In Linux, you can also make it executable by adding the recommended shebang in the first line:

#!/usr/bin/env wolframscript

And adding the executable bit, perhaps with:

chmod  +x ./export.wls