Home

Awesome

Eerie

Eerie is a package manager for Io. That means it's a program and a package itself, which helps you to distribute your projects easier. It manages a project's dependencies: installs them, updates them, helps you reviewing dependencies etc.

It can handle packages hosted locally (i.e. a directory) and on the server. When it's on the server, it can be a git repository or a downloadable archive.

Installing

If you already installed Io, there is a big chance you installed Eerie as well. To check it, run:

$ eerie -v

In your terminal. If Eerie installed correctly, it'll print Eerie's version. If you instead getting something like:

zsh: command not found: eerie

Follow the instruction in Installing Manually.

Installing Manually

First of all, you should be sure that Eerie isn't installed. For Linux and macOS it's in $HOME/.eerie by default, for Windows it's CMAKE_INSTALL_PREFIX\eerie. If it's there, try to add the required path into your .shellrc file (i.e. ~/.bashrc for Bash, ~/.zshrc for ZSH):

export EERIEDIR=$HOME/.eerie
export PATH=$PATH:$EERIEDIR/base/bin:$EERIEDIR/activeEnv/bin

Then reload your terminal.

If your system clean from Eerie and you want to install from ground-up:

  1. Clone Eerie repo with git clone https://github.com/IoLanguage/eerie.git
  2. Change directory to Eerie repo (cd eerie)
  3. On Linux or macOS run:
$ . ./install_unix.sh

On Windows, run:

$ io setup.io

The scripts understand the next options:

Uninstalling

To uninstall Eerie just remove it's directory. By default it's $HOME/.eerie on Linux and macOS, and CMAKE_INSTALL_PREFIX\eerie on Windows.

Updating

To update Eerie run:

$ eerie selfUpdate

Environments

Eerie packages are installed globally for the current user. That means that instead of packages stored in a directory inside your project (like with NPM, for example), packages you install are available in any project.

While it keeps your system clean from duplicated packages, it introduces an issue, when you need different versions of the same package for different projects. To prevent it, Eerie uses Environments. An Environment is an isolated collection of packages. You can easily create as many environments as you wish. It's recommended to create an environment for each project.

Eerie has next commands to work with environments:

Packages

To better understand Eerie packages, we first look into a package structure.

First, we create a new package Foo:

$ eerie pkg:create Foo

Now let's look at what we got:

$ tree Foo
Foo
├── README.md
├── bin
├── hooks
├── io
│   └── Foo.io
├── package.json
└── source

4 directories, 3 files

The entry-point of your package is Foo.io file.

bin/ directory contains scripts, which you can use as any other binaries in your terminal. Eerie itself is a package with a binary eerie. So using Eerie, you can distribute not only packages, but also programs, written in Io.

hooks/ is a set of optional scripts, which run before or after downloading, installing and updating of your package. If you put here scripts named either: beforeDownload, afterDownload, beforeInstall, afterInstall, beforeUpdate or afterUpdate; it will run in an appropriate time.

package.json is the package's manifest. It's the file, which contains description of your package and dependencies it has.

source/ is a directory, where stored C source files of your package (if your package has native code).

Let's add some dependency to our package. We change package.json file so it looks like this:

{
  "name":         "Foo",
  "version":      "0.1.0",
  "description":  "",
  "author":       "",
  "website":      "",
  "readme":       "README.md",
  "protos":       ["Foo"],
  "dependencies": {
    "libs":     [],
    "headers":  [],
    "protos":   [],
    "packages": ["https://github.com/bekkopen/jasmineio.git"]
  }
}

And we install jasmineio, to make it available in our environment:

$ eerie install https://github.com/bekkopen/jasmineio.git

Now, when someone will install Foo, they'll get jasmineio installed as well. So you don't need to instruct the users of your package, which packages they need to make it work. You can also specify native libraries ("libs") and headers ("headers").

Let's look at available commands to work with packages:

Packages With C Code

Writing Eerie packages using C is better explained in NullAddon. It also may be considered a template for native packages.

Basically, except of the package code itself, you need a build.io file in which you can rewrite AddonBuilder to represent a receipt for your package. Here is the contents of build.io of the NullAddon:

# This clone is _required_ for the build process to function correctly.
# However, it doesn't actually have to do anything at all.  Therefore,
# I've commented out the stuff that you'd normally see, since it really
# doesn't depend on anything not already provided in the NullAddon
# software.

AddonBuilder clone do(
/*
 	if(list("cygwin", "mingw", "windows") contains(platform),
 		dependsOnLib("C-library-name-here")
 		dependsOnHeader("C-header-file-here.h")
 	)
 
 	if(list("darwin", "linux", "netbsd") contains(platform),
 		dependsOnLib("C-library-name-here")
 		dependsOnHeader("C-header-file-here.h")
 	)
 
 	debs    atPut("package-name-here", "DistroPackageNameHere")
 	ebuilds atPut("package-name-here", "DistroPackageNameHere")
 	pkgs    atPut("package-name-here", "DistroPackageNameHere")
 	rpms    atPut("package-name-here", "DistroPackageNameHere")
*/
)