This code generates a Dockerfile for a Selenium environment with VNC support by converting bash commands into Docker RUN instructions and combining them with code retrieved from an external importer function.

Run example

npm run import -- "selenium docker"

selenium docker

var importer = require('../Core');
var fs = require('fs');

// add some run commands to the bash script
function bashToRun(code) {
    return code.split('\n').filter(n => n.trim().length > 0).map(l => 'RUN ' + l.trim())
    .join('\n').replace(/\\\s*\nRUN\s*/ig, '\\\n ');
}

// create a selenium Dockerfile with a vnc connection
function seleniumDocker(outputFile) {
    const r = importer.interpret([
        'run selenium inside docker',
        // add some extra services
        'linux dev tools',
        'vnc html',
        'vnc in docker'
    ]);
    console.log(r);
    // save the Dockerfile
    fs.writeFileSync(outputFile, [
        r[0].code,
        // convert some results to Docker RUN commands instead of bash
        bashToRun(r[1].code),
        bashToRun(r[2].code),
        r[3].code,
    ].join('\n'));
    return r;
};
module.exports = seleniumDocker;

const importer = require('../Core');
const fs = require('fs').promises; // Use promises for file system operations

/**
 * Converts bash commands to Docker RUN commands.
 * @param {string} code - The bash code to convert.
 * @returns {string} The converted Docker RUN commands.
 */
function bashToRun(code) {
    // Split the code into lines, filter out empty lines, and map each line to a RUN command
    return Array.from(code.split('\n'))
       .filter(line => line.trim().length > 0)
       .map(line => `RUN ${line.trim()}`)
       .join('\n').replace(/\\\s*\nRUN\s*/ig, '\\\n ');
}

/**
 * Creates a Selenium Dockerfile with VNC connection.
 * @param {string} outputFile - The path to the output file.
 * @returns {Promise} A promise that resolves when the Dockerfile is created.
 */
async function seleniumDocker(outputFile) {
    try {
        // Interpret the code to generate the Dockerfile instructions
        const r = await importer.interpret([
            'run selenium inside docker',
            'linux dev tools',
            'vnc html',
            'vnc in docker'
        ]);
        
        // Log the results for debugging purposes
        console.log(r);
        
        // Assemble the Dockerfile instructions
        const dockerfileContent = [
            r[0].code,
            bashToRun(r[1].code),
            bashToRun(r[2].code),
            bashToRun(r[3].code), // Convert the last instruction to a RUN command
            r[3].code // Append the original instruction
        ].join('\n');
        
        // Save the Dockerfile
        await fs.writeFile(outputFile, dockerfileContent);
    } catch (error) {
        // Handle any errors that occur during the process
        console.error(error);
    }
}

module.exports = seleniumDocker;

This code defines two functions, bashToRun and seleniumDocker, to generate a Dockerfile for running Selenium with a VNC connection.

bashToRun(code):

• Takes a string of bash commands as input.
• Splits the input into lines, removes empty lines, and prepends "RUN " to each line.
• Joins the lines back together with newline characters and replaces any consecutive "RUN" commands with a single "RUN" followed by a newline.
• Returns the modified string, effectively converting bash commands into Docker RUN instructions.

seleniumDocker(outputFile):

• Imports the Core module and the fs module for file system operations.
• Calls the importer function with a list of instructions:
  • "run selenium inside docker"
  • "linux dev tools"
  • "vnc html"
  • "vnc in docker"
• This likely retrieves code snippets or instructions for setting up a Selenium environment within a Docker container, including VNC support.
• Writes the generated Dockerfile content to the specified outputFile.
• The Dockerfile content includes:
  • The initial code snippet from the importer function.
  • The bash commands from the importer function converted to Docker RUN commands using bashToRun.
• Returns the result from the importer function.

In essence, this code generates a Dockerfile for a Selenium environment with VNC capabilities based on instructions retrieved from the importer function.