lilypond-user
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

RE: lyp - a Package Manager for Lilypond


From: Mike Solomon
Subject: RE: lyp - a Package Manager for Lilypond
Date: Fri, 29 Jan 2016 08:09:56 +0200

Congratulations!
This is a wonderful accomplishment and I am looking forward to getting some of my packages in good shale and contributing them. Do you have a contributor's guide yet?

Cheers,
MS



Sent from my Samsung Galaxy smartphone.
-------- Original message --------
From: Sharon Rosner <address@hidden>
Date: 28/01/2016 11:52 PM (GMT+02:00)
To: address@hidden
Subject: lyp - a Package Manager for Lilypond

Hello all,

I'd like to announce lyp - a package manager for Lilypond:

   https://github.com/noteflakes/lyp <https://github.com/noteflakes/lyp> 

I started writing lyp a couple of months ago, as a result of discussions Urs
Liska, Matteo Ceccarello and me were having a on how to go about
implementing a package manager for Lilypond. Here's an overview:

lyp does two things: install and manage packages of Lilypond code; and
install and manage multiple versions of Lilypond. It currently works on
Linux and Mac OSX. Support for Windows is coming. lyp offers the following
functionality:

- Install and use versioned packages from git repositories (see below).
- Automatically install sub-dependencies.
- Support for version constraints (e.g. >=0.1.2, ~>0.1.0, a.k.a pessimistic
constraint)
- Resolve dependency trees of arbitrary depth.
- Automatically install custom fonts included in packages, automatically
patch Lilypond versions prior to 2.19.12 in order to support using custom
fonts.
- Run package test files.
- Easily install and switch between different versions of Lilypond using a
single command.

In addition, there's:

-  lyp-index <https://github.com/noteflakes/lyp-index>  , a semi-official
index for packages, mapping canonical names to git URLs.
- an assert package, which provides scheme procedures for assertion which
can be used for testing a package, or indeed any Lilypond code (see below).

Currently, of course, there doesn't exist much in the way of actual
packages. But you can have a look at two packages which are already usable,
*with tests*:

-  assert <https://github.com/noteflakes/lyp-assert>   - a package providing
assertion functionality for scheme code. This package also includes a test
file demonstrating usage of the assert:* procedures.
-  roman-numerals <https://github.com/noteflakes/lyp-roman-numerals>   - a
fork of David Nalesnik's work on roman numerals for harmonic analysis.

(both of these packages also show how lyp can be integrated into a project's
build process in order to automatically install Lilypond and run test files
- in this case on travis-ci.)

The goal of lyp is to facilitate code sharing and reuse in the Lilypond
community, to encourage cooperation on Lilypond-related projects, and above
all to make life easier for Lilypond users. It does so by both offering a
simple, cross-platform solution for installing Lilypond, and by offering
tools for sharing Lilypond code such as testing, publishing, and installing
packages.

I believe lyp can make a real difference in how the Lilypond community
shares code. I welcome all questions, remarks and suggestions. What follows
is a brief technical discussion of the main points which I think demand
explanation. Please note that lyp is still under heavy development, so
things might change drastically in the near future.

*Packages*

A package is any git repository that contains at least one file called
package.ly, which serves as the entry point for the package. The package can
include other Lilypond scheme files, as well as fonts which are installed
automatically into any installed version of Lilypond.

Packages can be referenced in input files by using the \require command,
which is automatically defined by lyp when invoking Lilypond. Packages can
be versioned, and can be referenced using version constraints (e.g. \require
"openlilylib>=1.0.0").

Packages can be referenced either using a partially- or fully-qualified git
URL, a github id, or a canonical name (provided they are registered in the
lyp-index <https://github.com/noteflakes/lyp-index>  ).

Packages can also depend on other packages, creating dependency trees of
arbitrary depth. lyp takes care of resolving the dependency tree for a given
input file, selecting the correct version to use for each dependency.
Packages are versioned using git tags.

Installing a package is as simple as:

    lyp install assert
 
lyp takes care of cloning the package's repository, searching for the
correct version to use (in this case the highest version). lyp can also
install a package from local files, for development purposes.

*Installing Lilypond*

lyp provides a command for installing arbitrary versions of lilypond. For
example:

    lyp install address@hidden
    # or
    lyp install address@hidden # install the latest stable version
 
Versions are installed in separate directories under ~/.lyp/lilyponds. For
invocation see below.

*Package loading*

lyp provides its own Lilypond binary, which does the following:

- Select the correct version of Lilypond to use (based on user settings or
environment variables).
- Scan the input file for any dependencies (specified using \require), and
also recursively scan any include files for dependencies.
- Resolve the dependency tree and calculate the correct version to use for
each required package.
- Create a small Lilypond 'shim' file that provides both package loading
information, as well as definitions for a scheme interface used for loading
package files, then finally loads the input file.
- Compile the shim file using the selected version of Lilypond.

*How lyp is made*

lyp is written in Ruby. It can be installed either as a Ruby gem, or as a
standalone package for those who don't have Ruby on their machines.

lyp is pretty well tested, with over 60 different tests actually installing
different versions of Lilypond, installing packages, running Lilypond test
files, and testing the lyp package scheme interface using assert, which is
itself a lyp package installed by lyp (that's pretty meta right there.)

---

So, I hope this proves interesting to the people here. Again, I welcome any
questions, remarks or suggestions you may have.

Happy Lilyponding,
Sharon Rosner



--
View this message in context: http://lilypond.1069038.n5.nabble.com/lyp-a-Package-Manager-for-Lilypond-tp186597.html
Sent from the User mailing list archive at Nabble.com.

_______________________________________________
lilypond-user mailing list
address@hidden
https://lists.gnu.org/mailman/listinfo/lilypond-user

reply via email to

[Prev in Thread] Current Thread [Next in Thread]