Recently, I’ve been using a Moose utility (MooseEasyUtility) to ease the creation and loading of a Moose Model. In turn, this utility uses the LibC to send various commands to the operating system for example to call the VerveineJ parser. However, when using this library, I encountered a problem on my Windows machine. The problem was caused by an encoding issue between the Java Parser (VerveineJ) and the file reader in Pharo. This is Windows specific as there was no issue when running my program on a Linux-based machine.
Sometimes you have to use the Windows OS like me, or you want to build an interoperable application that runs on multiple applications. Your Pharo program may eventually run on a Windows or Linux-based OS; however, you may not be familiar with Windows. Luckily, Microsoft has finally opened up its system to introduce the Windows Subsystem Linux (WSL).
WSL is a compatibility layer for running Linux binary executables (in ELF format) natively on Windows 10. Furthermore, in 2019, Microsoft introduced WSL 2, which included important changes such as a real Linux kernel, through a subset of Hyper-V features. The important thing to remember is that it allows us to use bash commands on Windows 10.
There are two ways to install WSL on your machine. The simplified installation requires that you join the Windows Insider Program and run the command
wsl --install. The manual installation is a bit more complicated but the steps are detailed on docs-microsoft.
Once installed you may access WSL by either launching WSL through the search bar or by running your favorite terminal and using the command
You can also type wsl in your terminal to access the WSL directly.
The next step after installing WSL on your machine is to launch your favorite image of Pharo. From there you can use the class LibC to run some commands:
LibC resultOfCommand: 'ls'. LibC resultOfCommand: 'wsl ls'.
As you will see, when the first command is sent, the terminal returns an error as Windows does not recognize the
However, when you execute
ls with the
wsl command, it can now successfully display the list of files in the current directory.
Let’s come back to our problem with Moose-Easy. Moose-Easy is a library to facilitate access to Moose, e.g. to generate MSE files from a source code. Originally, I wanted to use Moose-Easy to parse and generate a model of the Java project I was working on. In my project, I passed the path to the source code, the parser, and any project dependencies I wanted to analyze.
generate "Generates this model importer's model from its origin into its configured model path, using its parser" MooseEasyUtility createJavaMSEOn: self originSrcPath asFileReference asPath using: self parser path asFileReference pathString named: self modelPath asFileReference pathString withDependencies: self dependenciesFolder
This method uses
MooseEasyUtility to generate the model as a MSE file which would be later imported.
import method from my project imports the MSE as a Moose Model.
import "Imports this model importer's model from its configured model path" self modelPath asFileReference readStreamDo: [ :stream | model := MooseModel importFromMSEStream: stream. model rootFolder: self originPath; install. ^ model ]
An important feature of the Moose Model is the ability to access/visualize the source code of an entity.
To enable this, during the generation of the MSE, the parser (here VerveineJ) creates a SourceAnchor which writes the start position and end position of the entity within a specific file.
However, when manipulating the model, I noticed that the sourceAnchors’ start/end positions were shifted.
This resulted in accessing the wrong portions of the source code for each entity. After investigating this shift, it became clear it was due to an encoding issue with the carriage return.
When the parser accessed the file it read it the carriage returns differently than when it was being accessed by the Moose library.
To fix this issue without modifying the parser, I used WSL commands to run my parser.
More precisely, I replaced the direct call to the parser executable with a call to wsl to run the parser.
The following instruction of
MooseEasyUtility was changed from:
command := 'cd "' , revPath asFileReference pathString , '" && "' , pathToJavaToFamixCommand , '" ' , verveineJOptions , ' > "' , javaToFamixOutput fullName , '"' , ' 2> "' , javaToFamixErrors fullName , '"'. result := LibC runCommand: command.
command := 'cd "' , revPath asFileReference pathString , '" && wsl"' , pathToJavaToFamixCommand , '" ' , verveineJOptions , ' > "' , javaToFamixOutput fullName , '"' , ' 2> "' , javaToFamixErrors fullName , '"'. result := LibC runCommand: command.
Notice that instead of calling the JavaToFamixCommand (i.e. VerveineJ) directly, it is now called through
wsl (end of first line).
This allowed me to generate a MSE file that contained the correct start/end positions.
Additionaly, it is important to remember that if an absolute path is passed to wsl, it must be formatted according to Linux and WSL conventions. On Windows, the path to a file may look like this
C:\Users\Pascal.ZARAGOZA\eclipse-workspace. While the WSL absolute path will look like this
/mnt/c/Users/Pascal.ZARAGOZA/eclipse-workspace. This is why I recommend to use relative paths whenever possible when using a mix of WSL and Windows commands.
If you are interested in analyzing your java project with Moose 8, there is a detailed blog post by Christopher Fuhrman on the subject.
It covers the whole process of using
MooseEasyUtility to clone, parse, and load the corresponding model of a java project.
It also demonstrates how to both visualize and analyze the moose model.