lyp 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: be34fcbc627f99a4a4e3859e3c3629f69604a621
-  data.tar.gz: 7141ac8c3ec2d892218022810877584f05b2afb2
+  metadata.gz: 86f269cc3a5d4371afd93fdb52179687f39e004d
+  data.tar.gz: b7e7ab100e40d0be46b4d61c4d3a2aa1aa371c38
 SHA512:
-  metadata.gz: 1bfb4b6e26d1b552613791a58bfdeb9a65c338cf62efaa0cce537361d06a6fbc0b65f2c8bc422242f8707061a7f3541898fcb6cdc7701f3c873d96b1affc9f8e
-  data.tar.gz: 66b0af75bb43ee1fca671ccd967ec046971320a28dc30d4c5ed71dc19b99ae59f5ee5f7974a43c505e6a6d88962374149f7f2a2483eb5882da4b136d20bd4f6b
+  metadata.gz: 64f17f1ca324b90ca147fc5bd41c77e52f42bc960b145204ecffb3926deda54e84930881a1f1d809e458151f27d94d17f025474cc06c40c9b6a2d7f87a34ff73
+  data.tar.gz: 81ec32c68983e53bd1eff21e524ff2f1143c97dae6b4ba8017055da48b40839da4dae9591b147a47f2f36b8ceb9f7e4fb0456aeeef1e834a289b78f3e6d9dfbf

data/README.md

@@ -16,6 +16,7 @@ __No hassle Lilypond installation__: With lyp you can also install any version o
 - [Working with packages](#working-with-packages)
   - [What constitutes a package?](#what-constitutes-a-package)
   - [Installing packages](#installing-packages)
+  - [Automatic package installation](#automatic-package-installation)
   - [Package references](#package-references)
   - [Version specifiers](#version-specifiers)
   - [Using packages](#using-packages)
@@ -25,7 +26,12 @@ __No hassle Lilypond installation__: With lyp you can also install any version o
   - [Including fonts](#including-fonts)
   - [Testing packages](#testing-packages)
   - [Publishing packages](#publishing-packages)
-- [Installing and switching Lilypond versions](#installing-and-switching-lilypond-versions)
+- [Installing and Using Lilypond](#installing-and-using-lilypond)
+  - [Installing/uninstalling a version of lilypond](#installing-uninstalling a version of lilypond)
+  - [Showing the list of installed lilypond versions](#showing-the-list-of-installed-lilypond-versions)
+  - [Showing available lilypond versions](#Showing-available-lilypond-versions)
+  - [Switching between lilypond versions](#switching-between-lilypond-versions)
+  - [Running lilypond](#running-lilypond)
 - [Contributing](#contributing)
 
 ## Installation
@@ -37,27 +43,38 @@ __No hassle Lilypond installation__: With lyp you can also install any version o
 If you have a recent (>=1.9.3) version of Ruby on your machine, you can install lyp as a gem:
 
 ```bash
-gem install lyp
-lyp install self
+$ gem install lyp
+$ lyp install self
 ```
 
 The `lyp install self` command is needed in order to setup the `~/.lyp` working directory and add the lyp binaries directory to your `PATH` (see below), by adding a line of code to your shell profile file.
 
 #### Installing lyp without Ruby
 
-If you don't have Ruby on your machine you can install lyp as a stand alone package using the [install script](https://raw.githubusercontent.com/noteflakes/lyp/master/bin/install_release.sh):
+If you don't have Ruby on your machine you can install lyp as a stand alone package using the install script ([view source](https://git.io/getlyp)):
 
 ```bash
-curl -sSL https://git.io/getlyp | bash
+$ curl -sSL https://git.io/getlyp | bash
 ```
 
 or with Wget:
 
 ```bash
-wget -qO- https://git.io/getlyp | bash
+$ wget -qO- https://git.io/getlyp | bash
 ```
 
-**Note**: installing the standalone release of lyp requires having git on your machine.
+If you feel uneasy about piping curl output to bash, you can install lyp yourself by downloading a [release](https://github.com/noteflakes/lyp/releases), untarring it, and running `lyp install self`:
+
+```bash
+$ cd /Downloads
+# assuming linux-64 platform
+$ tar -xzf lyp-0.2.1-linux-x86_64.tar.gz
+$ lyp-0.2.1-linux-x86_64/lyp install self
+```
+
+https://github.com/noteflakes/lyp/releases/download/v0.2.1/lyp-0.2.1-linux-x86_64.tar.gz
+
+**Note**: using the standalone release of lyp requires having git on your machine.
 
 ### How lyp works
 
@@ -69,12 +86,14 @@ Lyp sets up a working directory in `~/.lyp` where it keeps its binaries,  instal
 - Create a wrapper lilypond file that loads the packages.
 - Invoke the selected version of lilypond.
 
+For more information on running lilypond see the section on [Running lilypond](#running-lilypond).
+
 ### Uninstalling
 
 In order to remove lyp from your system use the `uninstall self` command:
 
 ```bash
-lyp uninstall self
+$ lyp uninstall self
 ```
 
 This command will undo the changes made to your shell profile file, and remove any binaries from `~/.lyp/bin`.
@@ -82,7 +101,7 @@ This command will undo the changes made to your shell profile file, and remove a
 In order to completely remove all files in `~/.lyp` you can simply delete the directory:
 
 ```bash
-rm -rf ~/.lyp
+$ rm -rf ~/.lyp
 ```
 
 ## Working with Packages
@@ -102,31 +121,77 @@ Lilypond packages are expected to be published as git repositories. The packages
 In order to install a package, use the `lyp install` command:
 
 ```bash
-lyp install dummy # install latest version of package dummy
-lyp install github.com/ciconia/mypack@0.2.0 # install version 0.2.0
-lyp install mypack>=0.1.0 # install version 0.1.0 or higher
-lyp install mypack@dev:~/repo/mypack # install from local opath
+# install latest version of package dummy
+$ lyp install dummy
+
+# install version 0.2.0
+$ lyp install github.com/ciconia/mypack@0.2.0
+
+# install version 0.1.0 or higher
+$ lyp install "mypack>=0.1.0"
+
+# install from local path (see section below on developing packages)
+$ lyp install mypack@dev:~/repo/mypack
 ```
 
 To uninstall the package, use the `lyp uninstall` command:
 
 ```bash
-lyp uninstall dummy@0.1.0 # uninstall version 0.1.0
-lyp uninstall -a dummy # uninstall all versions of dummy
+# uninstall version 0.1.0
+$ lyp uninstall dummy@0.1.0
+
+# uninstall all versions of dummy
+$ lyp uninstall -a dummy
 ```
 
 To list currently installed packages use `lyp list` command:
 
 ```bash
-lyp list # list all installed packages
-lyp list font # list all installed packages matching the pattern 'font'
+# list all installed packages
+$ lyp list
+
+# list all installed packages matching the pattern 'font'
+$ lyp list font
 ```
 
 To list packages available on the lyp package index use the `lyp search` command:
 
 ```bash
-lyp search # list all packages in index
-lyp search stylesheet # list available packages matching pattern 'stylesheet'
+# list all packages in index
+lyp search
+
+# list available packages matching pattern 'stylesheet'
+lyp search stylesheet
+```
+
+### Automatic package installation
+
+An easier way to install packages is by using the `lyp resolve` command, which installs all packages required for a given input file. Suppose a lilypond called `test.ly` with the following content:
+
+```lilypond
+\version "2.19.35"
+\require "assert"
+
+#(assert-eq? 1 1)
+#(assert:summary)
+```
+
+To install the `assert` package required in the file we run:
+
+```bash
+$ lyp resolve test.ly
+#=>
+Cloning https://github.com/noteflakes/lyp-assert.git...
+
+Installed assert@0.2.0
+```
+
+Package dependencies for a given input file can be shown using the `lyp deps` command:
+
+```bash
+$ lyp deps test.ly
+#=>
+  assert => 0.2.0
 ```
 
 ### Package references
@@ -134,16 +199,21 @@ lyp search stylesheet # list available packages matching pattern 'stylesheet'
 A package is normally referenced by its git URL. Lyp lets you provide either fully- or partially qualified URLs. A package hosted on github can be also referenced by the user/repository pair. The following are all equivalent:
 
 ```bash
-lyp install https://github.com/noteflakes/lyp-package-template.git
-lyp install https://github.com/noteflakes/lyp-package-template
-lyp install github.com/noteflakes/lyp-package-template
-lyp install noteflakes/lyp-package-template
+# Fully-qualified URLs
+$ lyp install https://github.com/noteflakes/lyp-package-template.git
+$ lyp install https://github.com/noteflakes/lyp-package-template
+
+# Partially-qualified URL
+$ lyp install github.com/noteflakes/lyp-package-template
+
+# Github repository id
+$ lyp install noteflakes/lyp-package-template
 ```
 
 In addition, lyp also provides an [index of publically available package](https://github.com/noteflakes/lyp-index), which maps a package name to its URL (see also below). Using the index, packages are referenced by their published name instead of by their git URL:
 
 ```bash
-lyp install dummy
+$ lyp install dummy
 ```
 
 To get a list of all available packages on the index, use the `lyp search` command.
@@ -169,21 +239,23 @@ Version constraints specify a range of versions to use. Lyp currently supports t
 Version specifiers could be used when installing, listing and requiring packages, and also for specifying versions of lilypond (see below). For example:
 
 ```bash
-lyp install "dummy~>0.2.0"
+$ lyp install "dummy~>0.2.0"
 ```
 
-(__Note__: that when using version constraints you should put the package specifier in quotes)
+**Note**: when using version constraints you should put the package specifier in quotes for bash properly parse the command.
 
-### Using packages
+### Requiring packages
 
-To include a package in your lilypond code, use ther `\require` command:
+To include a package in your lilypond code, use the `\require` command:
 
 ```lilypond
 \require "dummy"
 \require "github.com/lulu/mypack>=0.4.0"
 ```
 
-It is important to note that once you use `\require` in your code, you will have to compile it using the lilypond wrapper provided by lyp. It will not pass compilation using plain lilypond.
+**Note**: once you use `\require` in your code, you will have to compile it using the lilypond wrapper provided by lyp. It will not pass compilation using plain lilypond.
+
+Once the package requirements are defined, you can either install packages manually using [`lyp install`](#installing-packages), or automatically using [`lyp resolve`](#automatic-package-installation) as described above.
 
 ## Developing packages
 
@@ -195,18 +267,24 @@ To create a lilypond package:
 - Test & debug your code (see below).
 - Publish your package (see below).
 
-To test your package with an actual input file, you can install it from a local path (for more on testing [see below](#testing)). Suppose your package is at ~/repo/mypack:
+To test your package with an actual input file, you can install it from a local path (for more on testing see [below](#testing-packages)). Suppose your package is at ~/repo/mypack:
 
 ```bash
-lyp install mypack@dev:~/repo/mypack
+$ lyp install mypack@dev:~/repo/mypack
 ```
 
-This will create a `mypack@dev` package referencing your local files, which you can then reference from a test file in your package using the `\require` command:
+This will create a `mypack@dev` package referencing your local files, which you can then reference normally from an input file using the `\require` command:
 
 ```lilypond
 \require "mypack@dev"
 ```
 
+If the input file is residing inside your package (for example, [test files](#testing-packages)), you can require your package by specifying a relative path. Suppose the input file is at `mypack/test/mypack_test.ly`:
+
+```lilypond
+\require "mypack:.."
+```
+
 ### The package interface
 
 In order to facilitate writing complex packages, lyp defines a few variables and functions:
@@ -224,13 +302,13 @@ Lyp provides the `\pinclude` and `\pincludeOnce` commands for including files re
 \pinclude "inc/template.ily"
 ```
 
-Lyp also defines a `pload` scheme function for loading scheme files using relative paths without adding directories to the `%load-path`:
+Lyp also defines a `lyp:load` scheme function for loading scheme files using relative paths without adding directories to the `%load-path`:
 
 ```lilypond
-#(if (not (defined? 'mypack:init))(pload "scm/init.scm"))
+#(if (not (defined? 'mypack:init))(lyp:load "scm/init.scm"))
 ```
 
-Loading scheme files that way is better, because this way one avoids possible name clashes, which may lead to unexpected behavior.
+Loading scheme files that way is a better technique than adding directorys to `%load-path`, because this way one avoids possible name clashes, which may lead to unexpected behavior.
 
 ### Including fonts
 
@@ -243,8 +321,8 @@ Lyp also supports automatic installation of fonts, based on work by [Abraham Lei
 Packages can be tested by using the `lyp test` command, which will compile any file found inside the package directory ending in `_test.ly`:
 
 ```bash
-cd mypack
-lyp test .
+$ cd mypack
+$ lyp test .
 ```
 
 A test file can either be a simple lilypond file which includes the package files and results in a lilypond score, or a lilypond file that performs unit tests on scheme code.
@@ -257,58 +335,174 @@ In order for your package to be available to all users, you'll need to first pus
 
 You can also add your package to the lyp [public package index](https://github.com/noteflakes/lyp-index), by cloning it, editing [index.yaml](https://github.com/noteflakes/lyp-index/blob/master/index.yaml), and creating a pull request.
 
-## Installing and switching Lilypond versions
+## Installing and Using Lilypond
+
+### Installing/uninstalling a version of lilypond
 
 When installing lilypond, the specific version to download can be specified in different ways:
 
 ```bash
-lyp install lilypond % latest stable version
-lyp install lilypond@stable % latest stable version
-lyp install lilypond@unstable % latest stable version
-lyp install lilypond@latest % latest version
-lyp install lilypond@2.18.1 % version 2.18.1
-lyp install "lilypond>=2.19.27" % highest version higher than 2.19.27
-lyp install "lilypond~>2.18.1" % highest 2.18 version higher than 2.18.1
+# latest stable version
+$ lyp install lilypond
+
+# latest stable version
+$ lyp install lilypond@stable
+
+# latest stable version
+$ lyp install lilypond@unstable
+
+# latest version
+$ lyp install lilypond@latest
+
+# version 2.18.1
+$ lyp install lilypond@2.18.1
+
+# highest version higher than 2.19.27
+$ lyp install "lilypond>=2.19.27"
+
+# highest 2.18 version higher than 2.18.1
+$ lyp install "lilypond~>2.18.1"
+```
+
+To uninstall a version lilypond use `lyp uninstall`
+
+```bash
+$ lyp uninstall lilypond@2.18.2
 ```
 
+### Showing the list of installed lilypond versions
+
 To display all installed versions of lilypond, use the `list` command:
   
 ```bash
-lyp list lilypond
+$ lyp list lilypond
+```
+
+The output will look as follows:
+
 ```
+Lilypond versions:
 
-This will also list any versions of lilypond found outside of the `~/.lyp` directory.
+=> 2.18.2
+   2.19.12
+ * 2.19.35
+
+# => - current
+# =* - current && default
+#  * - default
+```
+
+(For current, default settings see below)
+
+This will also list any versions of lilypond found on the user's `$PATH` outside of the `~/.lyp` directory (these versions will be marked as 'system' versions).
+
+### Showing available lilypond versions
 
 You can also list available versions of lilypond by using the `search` command:
 
 ```bash
-lyp search lilypond # display all available versions of lilypond
-lyp search "lilypond>=2.19" # display all available versions higher than 2.19
-lyp search "lilypond@stable" # display all available stable versions
+# display all available versions of lilypond
+$ lyp search lilypond
+
+# display all available versions higher than 2.19
+$ lyp search "lilypond>=2.19"
+
+# display all available stable versions
+$ lyp search "lilypond@stable"
 ````
 
+The output will look as follows:
+
+```
+Available versions of lilypond@stable:
+
+   2.8.8
+   2.10.0
+   2.10.33
+   2.12.0
+   2.12.3
+   2.14.0
+   2.14.2
+   2.16.0
+   2.16.1
+   2.16.2
+   2.18.0
+   2.18.1
+ * 2.18.2
+
+ * Currently installed
+```
+
+### Switching between lilypond versions
+
 To switch between versions use the `lyp use`. The same version specifiers could be used as for the `lyp install` command:
 
 ```bash
-lyp use lilypond@2.18.2 % or without the 'lilypond' identifier:
-lyp use stable % use latest stable version 
-lyp use unstable % use latest unstable version 
+$ lyp use lilypond@2.18.2 # the 'lilypond' identifier is optional
+
+# use latest stable/unstable versions
+$ lyp use stable
+$ lyp use unstable
 ```
 
-The setting of the current lilypond version to use will be maintained for the current shell session.
+**Note**: The setting of the current lilypond version to use will be maintained for the current shell session.
 
 In order to switch the default version of lilypond to use, add the `--default` switch:
 
 ```bash
-lyp use --default 2.19.35
+$ lyp use --default 2.19.35
+```
+
+The version used can be further controlled using the `--use` and `--env` options passed to `lilypond` (see below).
+
+As discussed [above](#showing-the-list-of-installed-lilypond-versions), the `lyp list lilypond` command displays the current and default settings. You can also display the path to the currently selected version by running `lyp which lilypond`:
+
+```bash
+$ lyp which lilypond
+#=> /Users/sharon/.lyp/lilyponds/2.18.2/bin/lilypond
 ```
 
+### Running lilypond
+
+Once one or more versions of lilypond are installed, the lilypond command may be used normally to compile lilypond files. Lyp adds a few extra options:
+
+- `--use`, `-u` - use a specific version of lilypond:
+
+  ```bash
+  $ lilypond --use=2.19.12 ...
+
+  # version constraints can also be used:
+  $ lilypond --use=">=2.19.12" ...
+  $ lilypond --use=stable ...
+  $ lilypond --use=latest ...
+  ```
+  
+- `--env`, `-E` - use a version set by the `$LILYPOND_VERSION` environment variable:
+
+  ```bash
+  $ LILYPOND_VERSION=2.18.2 lilypond --env ...
+  ```
+
+- `--install`, `-n` - install the specified version of lilypond if not present. This option works only in conjunction with `--env` or `--use`:
+
+  ```bash
+  $ lilypond -u2.19.35 -n ...
+  ```
+  
+- `--raw`, `-r` - do not pre-process input file (no scanning for dependencies, no wrapping).
+
+  ```bash
+  $ lilypond --raw ...
+  ```
+
 ## Contributing
 
-Lyp is written in Ruby, and its code is [available on github](https://github.com/noteflakes/lyp). To hack on it, siply clone the repository. To run the specs:
+Lyp is written in Ruby, and its code is [available on github](https://github.com/noteflakes/lyp). To hack on it, simply clone the repository. To run the specs:
 
 ```bash
-rspec
+$ cd lyp
+$ bundle install # needs to be run only once
+$ rspec
 ```
 
 Please feel free to submit issues and pull requests.

data/bin/install_release.sh

@@ -4,11 +4,8 @@ shopt -s extglob
 set -o errtrace
 set -o errexit
 
-fail() { log "\nERROR: $*\n" ; exit 1 ; }
-
-has() {
-  type "$1" > /dev/null 2>&1
-}
+fail() { log "\nERROR: $*\n" ; exit 1 }
+has() { type "$1" > /dev/null 2>&1 }
 
 download() {
   if has "curl"; then
@@ -21,7 +18,7 @@ download() {
 }
     
 WORKDIR="/tmp/lyp-release-installer"
-LYP_VERSION="0.2.0"
+LYP_VERSION="0.2.2"
 URL_BASE="https://github.com/noteflakes/lyp/releases/download/v$LYP_VERSION"
 
 PLATFORM=`uname -sp`

data/bin/lilypond

@@ -3,20 +3,86 @@
 require 'lyp/version'
 require 'lyp'
 
-STDERR.puts "Lyp version #{Lyp::VERSION}"
+def process_argv
+  options = {}
+  argv = ARGV.dup # copy for iterating
+  argv_clean = []
+  while arg = argv.shift
+    case arg
+    when '-r', '--raw'
+      options[:raw] = true
+    when '-E', '--env'
+      unless ENV['LILYPOND_VERSION']
+        STDERR.puts "$LILYPOND_VERSION not set"
+        exit 1
+      end
+      options[:use_version] = ENV['LILYPOND_VERSION']
+    when '-u', '--use'
+      options[:use_version] = argv.shift
+    when /^(?:\-u|\-\-use\=)"?([^\s]+)"?/
+      options[:use_version] = $1
+    when '-n', '--install'
+      options[:install] = true
+    else
+      argv_clean << arg
+    end
+  end
+  
+  [options, argv_clean]
+end
+$options, $argv = process_argv
 
-Lyp::Lilypond.check_lilypond!
-lilypond_path = Lyp::Lilypond.current_lilypond
-unless lilypond_path && File.file?(lilypond_path)
-  STDERR.puts "No version of lilypond found. To install lilypond run 'lyp install lilypond'."
+def get_lilypond_path
+  if $options[:use_version]
+    if $options[:install]
+      Lyp::Lilypond.install_if_missing($options[:use_version])
+    end
+    Lyp::Lilypond.force_version!($options[:use_version])
+  end
+  Lyp::Lilypond.check_lilypond!
+  Lyp::Lilypond.current_lilypond.tap do |path|
+    unless path && File.file?(path)
+      STDERR.puts "No version of lilypond found. To install lilypond run 'lyp install lilypond'."
+      exit 1
+    end
+  end
+rescue => e
+  STDERR.puts e.message
   exit 1
 end
+$lilypond_path = get_lilypond_path
+
+if $options[:raw]
+  exec("#{$lilypond_path} #{$argv[1..-1].join(' ')}")
+end
+
+OVERRIDING_LILYPOND_SWITCHES = %w{
+  -w --warranty
+  -v --version
+  scheme-sandbox
+}
+LILYPOND_HELP_SWITCHES = %w{
+  -h --help
+}
+LYP_LY_HELP = <<EOF
+Lyp-provided options:
+  -r, --raw                           run raw lilypond (no pre-processing)
+  -E, --env                           use version specified in $LILYPOND_VERSION
+  -u, --use=VERSION                   use the given version of lilypond
+  -n, --install                       install the given version if not found
+EOF
 
-case ARGV
-when [], ['-v'], ['--warranty'], ['scheme-sandbox']
-  exec("#{lilypond_path} #{ARGV.join(' ')}")
+case $argv.first
+when nil, *OVERRIDING_LILYPOND_SWITCHES
+  STDERR.puts "Lyp version #{Lyp::VERSION}"
+  exec("#{$lilypond_path} #{$argv.join(' ')}")
+  
+when *LILYPOND_HELP_SWITCHES
+  STDERR.puts "Lyp version #{Lyp::VERSION}"
+  puts `#{$lilypond_path} #{$argv.join(' ')}`
+  puts LYP_LY_HELP
 else
   begin
-    Lyp::Lilypond.compile(ARGV)
+    Lyp::Lilypond.compile($argv, $options)
   end
 end

data/lib/lyp/base.rb

@@ -25,6 +25,8 @@ module Lyp
   # etc/lyp.ly contains lyp:* procedure definitions for loading packages and
   # other support code.
   LYP_LY_LIB_PATH = File.expand_path('etc/lyp.ly', File.dirname(__FILE__))
+  
+  LILYPOND_NOT_FOUND_MSG = "No version of lilypond found.\nTo install lilypond run 'lyp install lilypond'"
 
   SETTINGS_FILENAME = 'settings.yml'
   

data/lib/lyp/cli.rb

@@ -39,10 +39,13 @@ LILYPOND_LEGEND = <<EOF
 
 EOF
 
+$cmd_options = {}
+
 class Lyp::CLI < Thor
   package_name "lyp"
   map "-v" => :version
   check_unknown_options! :except => :compile
+  class_option :verbose, aliases: '-V', :type => :boolean
   
   desc "version", "show Lyp version"
   def version
@@ -51,7 +54,7 @@ class Lyp::CLI < Thor
   
   desc "search [PATTERN|lilypond]", "List available packages matching PATTERN or versions of lilypond"
   def search(pattern = '')
-    # Lyp::System.test_installed_status!
+    $cmd_options = options
 
     pattern =~ Lyp::PACKAGE_RE
     package, version = $1, $2
@@ -68,9 +71,9 @@ class Lyp::CLI < Thor
       versions = Lyp::Lilypond.search(version)
   
       if versions.empty?
-        puts "\nNo versions of lilypond are available for download\n\n"
+        puts "\nNo available versions of lilypond@#{version} found\n\n"
       else
-        puts "\nAvailable versions of lilypond:\n\n"
+        puts "\nAvailable versions of lilypond@#{version}:\n\n"
         versions.each do |v|
           prefix = v[:installed] ? " * " : "   "
           puts "#{prefix}#{v[:version]}"
@@ -94,42 +97,61 @@ class Lyp::CLI < Thor
   end
 
   desc "compile [<option>...] <FILE>", "Invokes lilypond with given file"
-  method_option :install, aliases: '-i', type: :boolean, desc: 'Install the requested version of lilypond if not present'
-  method_option :env, aliases: '-e', type: :boolean, desc: 'Use version set by LILYPOND_VERSION environment variable'
+  method_option :install, aliases: '-n', type: :boolean, desc: 'Install the requested version of lilypond if not present'
+  method_option :env, aliases: '-E', type: :boolean, desc: 'Use version set by LILYPOND_VERSION environment variable'
+  method_option :use, aliases: '-u', type: :string, desc: 'Use specified version'
   def compile(*args)
-    $stderr.puts "Lyp #{Lyp::VERSION}"
-    Lyp::System.test_installed_status!
+    $cmd_options = options
 
     if options[:env]
-      Lyp::Lilypond.force_env_version!
-      if options[:install] && !Lyp::Lilypond.forced_lilypond
-        Lyp::Lilypond.install(Lyp::Lilypond.forced_version)
+      unless ENV['LILYPOND_VERSION']
+        STDERR.puts "$LILYPOND_VERSION not set"
+        exit 1
       end
-    else
-      # check lilypond default / current settings
-      Lyp::Lilypond.check_lilypond!
+      options[:use] = ENV['LILYPOND_VERSION']
     end
     
+    if options[:use]
+      if options[:install]
+        Lyp::Lilypond.install_if_missing(options[:use], no_version_test: true)
+      end
+      Lyp::Lilypond.force_version!(options[:use])
+    end
+
+    # check lilypond default / current settings
+    Lyp::Lilypond.check_lilypond!
+    
+    $stderr.puts "Lyp #{Lyp::VERSION}"
+    Lyp::System.test_installed_status!
     Lyp::Lilypond.compile(args)
   end
   
   desc "test [<option>...] [.|PATTERN]", "Runs package tests on installed packages or local directory"
-  method_option :install, aliases: '-i', type: :boolean, desc: 'Install the requested version of lilypond if not present'
-  method_option :env, aliases: '-e', type: :boolean, desc: 'Use version set by LILYPOND_VERSION environment variable'
-  method_option :all, aliases: '-a', type: :boolean, desc: ''
+  method_option :install, aliases: '-n', type: :boolean, desc: 'Install the requested version of lilypond if not present'
+  method_option :env, aliases: '-E', type: :boolean, desc: 'Use version set by LILYPOND_VERSION environment variable'
+  method_option :use, aliases: '-u', type: :string, desc: 'Use specified version'
   def test(*args)
-    $stderr.puts "Lyp #{Lyp::VERSION}"
+    $cmd_options = options
 
     if options[:env]
-      Lyp::Lilypond.force_env_version!
-      if options[:install] && !Lyp::Lilypond.forced_lilypond
-        Lyp::Lilypond.install(Lyp::Lilypond.forced_version)
+      unless ENV['LILYPOND_VERSION']
+        STDERR.puts "$LILYPOND_VERSION not set"
+        exit 1
       end
-    else
-      # check lilypond default / current settings
-      Lyp::Lilypond.check_lilypond!
+      options[:use] = ENV['LILYPOND_VERSION']
     end
     
+    if options[:use]
+      if options[:install]
+        Lyp::Lilypond.install_if_missing(options[:use], no_version_test: true)
+      end
+      Lyp::Lilypond.force_version!(options[:use])
+    end
+
+    # check lilypond default / current settings
+    Lyp::Lilypond.check_lilypond!
+    
+    $stderr.puts "Lyp #{Lyp::VERSION}"
     case args
     when ['.']
       Lyp::Package.run_local_tests('.')
@@ -142,6 +164,8 @@ class Lyp::CLI < Thor
   method_option :default, aliases: '-d', type: :boolean, desc: 'Set default lilypond version'
   method_option :test, aliases: '-t', type: :boolean, desc: 'Run package tests after installation'
   def install(*args)
+    $cmd_options = options
+
     raise "No package specified" if args.empty?
     
     args.each do |package|
@@ -161,6 +185,8 @@ class Lyp::CLI < Thor
   desc "uninstall <PACKAGE|lilypond|self>...", "Uninstall a package or a version of lilypond. When 'uninstall self' is invoked, lyp uninstalls itself from ~/.lyp."
   method_option :all, aliases: '-a', type: :boolean, desc: 'Uninstall all versions'
   def uninstall(*args)
+    $cmd_options = options
+
     Lyp::System.test_installed_status!
 
     raise "No package specified" if args.empty?
@@ -170,7 +196,7 @@ class Lyp::CLI < Thor
         Lyp::System.uninstall!
       when Lyp::LILYPOND_RE
         Lyp::System.test_installed_status!
-        Lyp::Lilypond.uninstall($1)
+        Lyp::Lilypond.uninstall($1, options)
       else
         Lyp::System.test_installed_status!
         Lyp::Package.uninstall(package, options)
@@ -181,6 +207,8 @@ class Lyp::CLI < Thor
   desc "use [lilypond@]<VERSION>", "Switch version of lilypond"
   method_option :default, aliases: '-d', type: :boolean, desc: 'Set default lilypond version'
   def use(version)
+    $cmd_options = options
+
     Lyp::System.test_installed_status!
 
     if version =~ Lyp::LILYPOND_RE
@@ -193,12 +221,19 @@ class Lyp::CLI < Thor
 
   desc "list [PATTERN|lilypond]", "List installed packages matching PATTERN or versions of lilypond"
   def list(pattern = nil)
+    $cmd_options = options
+
     Lyp::System.test_installed_status!
 
     if pattern == 'lilypond'
-      STDOUT.puts LILYPOND_PREAMBLE
-      Lyp::Lilypond.list.each {|info| puts format_lilypond_entry(info)}
-      STDOUT.puts LILYPOND_LEGEND
+      list = Lyp::Lilypond.list
+      if list.empty?
+        puts LILYPOND_NOT_FOUND_MSG
+      else
+        puts LILYPOND_PREAMBLE
+        list.each {|info| puts format_lilypond_entry(info)}
+        puts LILYPOND_LEGEND
+      end
     else
       list = Lyp::Package.list(args.first)
       if list.empty?
@@ -223,10 +258,17 @@ class Lyp::CLI < Thor
   
   desc "which [PATTERN|lilypond]", "List locations of installed packages matching PATTERN or versions of lilypond"
   def which(pattern = nil)
+    $cmd_options = options
+
     Lyp::System.test_installed_status!
 
     if pattern == 'lilypond'
-      puts Lyp::Lilypond.current_lilypond
+      current = Lyp::Lilypond.current_lilypond
+      if current
+        puts Lyp::Lilypond.current_lilypond
+      else
+        puts LILYPOND_NOT_FOUND_MSG
+      end
     else
       Lyp::Package.which(args.first).each {|p| puts p}
     end
@@ -234,6 +276,8 @@ class Lyp::CLI < Thor
   
   desc "deps FILE", "Lists dependencies found in user's files"
   def deps(fn)
+    $cmd_options = options
+
     resolver = Lyp::Resolver.new(fn)
     tree = resolver.get_dependency_tree(ignore_missing: true)
     tree[:dependencies].each do |package, leaf|
@@ -249,6 +293,8 @@ class Lyp::CLI < Thor
   desc "resolve FILE", "Resolves and installs missing dependencies found in user's files"
   method_option :all, aliases: '-a', type: :boolean, desc: 'Install all found dependencies'
   def resolve(fn)
+    $cmd_options = options
+
     resolver = Lyp::Resolver.new(fn)
     tree = resolver.get_dependency_tree(ignore_missing: true)
     tree[:dependencies].each do |package, leaf|
@@ -263,6 +309,6 @@ begin
   Lyp::CLI.start(ARGV)
 rescue => e
   puts e.message
-  puts e.backtrace.join("\n")
+  puts e.backtrace.join("\n") if $cmd_options[:verbose]
   exit(1)
 end

data/lib/lyp/lilypond.rb

@@ -1,5 +1,5 @@
-require 'httpclient'
 require 'uri'
+require 'httpclient'
 require 'open3'
 require 'ruby-progressbar'
 
@@ -57,11 +57,12 @@ module Lyp::Lilypond
     end
     
     def forced_lilypond
-      lilypond = lyp_lilyponds.find do |l|
-        l[:version] == @forced_version
+      lilypond = filter_installed_list(@forced_version)[0]
+      if lilypond
+        lilypond[:path]
+      else
+        raise "No installed version found matching '#{@forced_version}'"
       end
-      
-      lilypond && lilypond[:path]
     end
     
     def force_env_version!
@@ -71,6 +72,10 @@ module Lyp::Lilypond
       end
     end
     
+    def force_version!(version)
+      @forced_version = version
+    end
+    
     attr_reader :forced_version
     
     def check_lilypond!
@@ -81,7 +86,7 @@ module Lyp::Lilypond
     end
     
     def valid_lilypond?(path)
-      File.file?(path) && (`#{path} -v` =~ /^GNU LilyPond/)
+      (File.file?(path) rescue nil) && (`#{path} -v` =~ /^GNU LilyPond/)
     end
     
     def select_default_lilypond!
@@ -89,6 +94,8 @@ module Lyp::Lilypond
       if latest
         default = latest[:path]
         set_default_lilypond(default)
+      else
+        raise LILYPOND_NOT_FOUND_MSG
       end
     end
     
@@ -110,9 +117,14 @@ module Lyp::Lilypond
       Gem::Version.new(x[:version]) <=> Gem::Version.new(y[:version])
     end
     
-    def list
-      system_list = system_lilyponds
-      lyp_list = lyp_lilyponds
+    def filter_installed_list(version_specifier)
+      list = (system_lilyponds + lyp_lilyponds).sort!(&CMP_VERSION)
+      list.select {|l| version_match(l[:version], version_specifier, list)}
+    end
+    
+    def list(opts = {})
+      system_list = opts[:lyp_only] ? [] : system_lilyponds
+      lyp_list = opts[:system_only] ? [] : lyp_lilyponds
       
       default = default_lilypond
       unless default
@@ -191,21 +203,19 @@ module Lyp::Lilypond
     # Returns a list of versions of lilyponds available for download
     def search(version_specifier = nil)
       require 'open-uri'
-      require 'nokogiri'
 
       platform = detect_lilypond_platform
       url = "#{BASE_URL}/#{platform}/"
-      doc = Nokogiri::HTML(open(url))
       
       versions = []
-      doc.xpath("//td//a").each do |a|
-        if a[:href] =~ /^lilypond-([0-9\.]+)/
-          versions << $1
-        end
+      
+      open(url).read.scan(/a href=\"lilypond-([0-9\.]+)[^>]+\"/) do |m|        
+        versions << $1
       end
-
+      
       installed_versions = list.map {|l| l[:version]}
-      versions.select {|v| version_match(v, version_specifier, versions)}.map do |v|
+      versions.select! {|v| version_match(v, version_specifier, versions)}
+      versions.map do |v|
         {
           version: v,
           installed: installed_versions.include?(v)
@@ -238,6 +248,12 @@ module Lyp::Lilypond
       search.last[:version]
     end
     
+    def install_if_missing(version_specifier, opts = {})
+      if filter_installed_list(version_specifier).empty?
+        install(version_specifier, opts)
+      end
+    end
+    
     def install(version_specifier, opts = {})
       version = detect_version_from_specifier(version_specifier)
       raise "No version found matching specifier #{version_specifier}" unless version
@@ -394,7 +410,8 @@ module Lyp::Lilypond
         FileUtils.cp_r(dir, target_dir, remove_destination: true) if File.directory?(dir)
       end
       
-      STDERR.puts exec "#{target_dir}/bin/lilypond -v"  unless opts[:silent]
+      # Show lilypond versions
+      STDERR.puts `#{target_dir}/bin/lilypond -v` unless opts[:silent] || opts[:no_version_test]
     rescue => e
       puts e.message
     end
@@ -465,24 +482,29 @@ module Lyp::Lilypond
       lilypond
     end
     
-    def uninstall(version)
-      lilyponds = list.reverse
-      lilypond = lilyponds.find {|l| l[:version] == version && !l[:system]}
-      unless lilypond
-        raise "Invalid version specified: #{version}"
+    def uninstall(version_specifier, opts = {})
+      list = list(lyp_only: true)
+      if version_specifier
+        list.select! {|l| version_match(l[:version], version_specifier, list)}
+      elsif !opts[:all]
+        # if no version is specified
+        raise "No version specifier given.\nTo uninstall all versions run 'lyp uninstall lilypond -a'.\n"
       end
-      lilyponds.delete(lilypond)
-      latest = lilyponds.first
       
-      if lilypond[:default]
-        set_default_lilypond(latest && latest[:path])
-      end
-      if lilypond[:current]
-        set_current_lilypond(latest && latest[:path])
+      if list.empty?
+        if version_specifier
+          raise "No lilypond found matching #{version_specifier}"
+        else
+          raise "No lilypond found"
+        end
       end
       
-      lilypond_dir = File.expand_path('../..', lilypond[:path])
-      FileUtils.rm_rf(lilypond_dir)
+      list.each do |l|
+        puts "Uninstalling lilypond #{l[:version]}" unless opts[:silent]
+        set_current_lilypond(nil) if l[:current]
+        set_default_lilypond(nil) if l[:default]
+        FileUtils.rm_rf(l[:root_path])
+      end
     end
     
     def exec(cmd, raise_on_failure = true)

data/lib/lyp/version.rb

@@ -1,3 +1,3 @@
 module Lyp
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

metadata

@@ -1,35 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: lyp
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-28 00:00:00.000000000 Z
+date: 2016-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: highline
+  name: httpclient
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '2.7'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.7.8
+        version: 2.7.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '2.7'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.7.8
+        version: 2.7.1
 - !ruby/object:Gem::Dependency
   name: ruby-progressbar
   requirement: !ruby/object:Gem::Requirement
@@ -70,40 +70,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.19.1
-- !ruby/object:Gem::Dependency
-  name: httpclient
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.7'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.7.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.7'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.7.1
-- !ruby/object:Gem::Dependency
-  name: nokogiri
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 1.6.6.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 1.6.6.2
 - !ruby/object:Gem::Dependency
   name: rugged
   requirement: !ruby/object:Gem::Requirement