EOLANG Command Line Tool-Kit

This is a command-line tool-kit for EO programming languages, allowing you to compile EO programs, test, dataize, and check for errors.

First, you install npm and Java SE.

Then, you install eolang package, using npm:

npm install -g [email protected]

You can also use Homebrew (on macOS):

brew tap objectionary/eoc https://github.com/objectionary/eoc
brew install objectionary/eoc/[email protected]

Or install it via Nix flakes:

nix run github:objectionary/eoc

{
  inputs = {
    eoc.url = "github:objectionary/eoc";
    nixpkgs.url = "github:nixos/nixpkgs/nixos-25.05";
  };

  outputs = { self, nixpkgs, eoc, ... }: {
    nixConfigurations.<hostname> = nixpkgs.lib.nixosSystem {
      modules = [
        {
          nixpkgs.config.packageOverrides = pkgs: {
            eoc = eoc.packages.${system}.default;
          };
        }
      ];
    }
  };
}

After that, select one of the methods for installing the package:

#configuration.nix (Global)
{
  environment.systemPackages = with pkgs; [
    eoc
  ];
}

#configuration.nix (For user)
{
  users.users.<your-user-name>.packages = with pkgs; [
    eoc
  ];
}

#home.nix (For home-manager)
{
  home.packages = with pkgs; [
    eoc
  ];
}

Then, you write a simple EO program in hello.eo file in the current directory:

# My first object in EO!
[args] > hello
  QQ.io.stdout > @
    "Hello, world!\n"

Then, you run it:

eoc --easy dataize hello

That's it.

Commands

You can also do many other things with eoc commands (the flow is explained in this blog post):

• register finds necessary .eo files and registers them in a JSON catalog
• assemble parses .eo files into .xmir, optimizes them, and pulls foreign EO objects
• transpile converts .xmir files to the target programming language (Java by default)
• compile converts target language sources (e.g., .java) to binaries (e.g., .class)
• link puts all binaries together into a single executable binary
• dataize dataizes a single object from the executable binary
• test dataizes all visible unit tests
• lint finds style-related errors in EO and XMIR files
• jeo:disassemble converts Java .class files to .xmir (via jeo)
• jeo:assemble converts .xmir files to Java .class files (via jeo)

There are also commands that help manipulate with XMIR and EO sources (the list is not completed, while some of them are not implemented as of yet):

• audit inspects all required packages and reports their status
• foreign inspects all objects found in the program after the assemble step
• sodg generates .sodg from .xmir, further rederable as XML or Dot
• print generates .eo files from .xmir files
• generate_comments generates .json files with LLM-generated documentation for .eo structures
• docs generates HTML documentation from .xmir files
• latex generates .tex files from .eo sources
• fmt formats .eo files in the source directory
• ~~translate converts Java/C++/Python/etc. program to EO program~~
• ~~demu removes cage and memory objects~~
• ~~dejump removes goto objects~~
• ~~infer suggests object names where it's possible to infer them~~
• ~~flatten moves inner objects to upper level~~

This command line toolkit simply integrates other tools available in the @objectionary GitHub organization.

Linting

There are two ways to work with linting. The --easy option enables linting but ignores warnings, while the --blind option completely disables linting.

How to Test

To execute the project tests, use the following command:

npx grunt

This command will run all the testing steps, including tests, linting, coverage, and more. If you only need to run the tests, use:

npm test

To run a specific test based on its description, use the following command:

npm test -- --grep="<test-description>"

For example, to run a test with the description "formats EO files according to expected patterns," execute:

npm test -- --grep="formats EO files according to expected patterns"

You can also run a specific test file using npx grunt:

npx grunt --file=test/commands/test_fmt.js

How to Contribute

First, run npm install. Make your changes, run tests and then make a pull request.