lyp 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef089fcb7702e57734c1496c8df3b81ed9d9e261
-  data.tar.gz: b0e77559e40e9c485863a4695774892aa01a2941
+  metadata.gz: fdcd618c84a8c0ec5925b02d2e05fb62ee438f63
+  data.tar.gz: dda515b6fb0fc79f7ee868100323ff19a40d9742
 SHA512:
-  metadata.gz: 4f01ffb644327f54961b91565f5728d65d2e8e6ce30b02bff24426fca36c8bdd28c1bd6d13471865e2e4ae51c42a9a957c7b881aeb45406f5355c268af79378f
-  data.tar.gz: 2d07b484694dd7fd1a062c45a33e19ed988dcbff93a0a2d3eee638e9bb421dd8e13a0524131162707361afa276c7669e89b05d57c5d716935d2cee086c8780e0
+  metadata.gz: 52a2954b3b7456fcda5e1d4e729e235c6c7aca2505b3f82d55e3ff467332b3a2094792db66783fd0d7fb4cefe28f02c21848c45ce2466d22dba057bc1e42232f
+  data.tar.gz: c9c533504e0a696bf0b7dfc6bbf5cbb2eabe9345a35ece672385340b9c0dea2c9840e15c3259a9370f84cfc371689c4f2e620aaffb312c1428f3cd30223979b2

data/README.md

@@ -38,27 +38,46 @@ __No hassle Lilypond installation__: With lyp you can also install any version o
   - [Testing packages](#testing-packages)
   - [Publishing packages](#publishing-packages)
 - [Installing and Using Lilypond](#installing-and-using-lilypond)
-  - [Installing/uninstalling a version of Lilypond](#installing-uninstalling a version of lilypond)
+  - [Installing/uninstalling a version of Lilypond](#installinguninstalling-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)
+- [Command Reference](#command-reference)
+  - [lyp accelerate](#lyp-accelerate) - rewrite gem binaries for faster execution
+  - [lyp benchmark](#lyp-benchmark) - benchmark installed versions of Lilypnd
+  - [lyp cleanup](#lyp-cleanup) - cleanup temporary files
+  - [lyp compile](#lyp-compile) - compile Lilypond source files
+  - [lyp deps](#lyp-deps) - show dependencies for a given source file
+  - [lyp exec](#lyp-exec) - execute a Lilypond script
+  - [lyp flatten](#lyp-flatten) - flatten a Lilypond project by inlining includes
+  - [lyp install](#lyp-install) - install package or Lilypond
+  - [lyp list](#lyp-list) - list installed packages or Lilyponds
+  - [lyp resolve](#lyp-resolve) - resolve and install dependencies for a given source file
+  - [lyp search](#lyp-search) - search for packages or Lilyponds
+  - [lyp test](#lyp-test) - run Lilypond test files
+  - [lyp uninstall](#lyp-uninstall) - uninstall packages or Lilyponds
+  - [lyp update](#lyp-update) - update packages
+  - [lyp use](#lyp-use) - switch between installed Lilyponds
+  - [lyp version](#lyp-version) - show lyp version
+  - [lyp watch](#lyp-watch) - watch files and directories and recompile on change
+  - [lyp which](#lyp-which) - show location of packages or Lilyponds
 - [Contributing](#contributing)
 
 ## Installation
 
 ### System requirements
 
-Lyp is tested to work on Linux, MacOS and Windows 7+.
+Lyp is tested to work on Linux, macOS and Windows 7+.
 
 ### Installing lyp as a Ruby gem
 
-_Note_: A recent version of Ruby (2.0.0 or later) is included in MacOS 10.9.0 or later.
+_Note_: A recent version of Ruby (2.0.0 or later) is included in macOS 10.9.0 or later.
 
 If you have a recent (>=1.9.3) version of Ruby on your machine, you can install lyp as a gem.
 
 ```bash
-# Linux/MacOS:
+# Linux/macOS:
 $ gem install lyp
 
 # Windows:
@@ -88,7 +107,7 @@ Windows users can simply download the latest Windows [release](https://github.co
 
 ### Manually installing releases
 
-(This section is for Linux / MacOS users.)
+(This section is for Linux / macOS users.)
 
 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`:
 
@@ -575,6 +594,177 @@ Once one or more versions of Lilypond are installed, the Lilypond command may be
   $ lilypond --ulatest myfile.ly
   ```
 
+## Command Reference
+
+### lyp accelerate
+
+Synopsis: `lyp accelerate`
+
+__Power users__: rewrite gem binaries for faster execution. When lyp is installed as a gem, the Rubygems system creates wrapper script files for `lyp` and `lilypond` which incur a performance penalty that adds up to 200msecs per invocation. Use this command to rewrite the gem binaries so as to improve their running time.
+
+### lyp benchmark
+
+Synopsis: `lyp benchmark FILE`
+
+__Power users__: benchmark the running time of all installed versions of Lilypond using the given source file. This command accepts all Lilypond command line switches.
+
+### lyp cleanup
+
+Synopsis: `lyp cleanup`
+
+Cleanup temporary files. lyp keeps a bunch of temporary directories and files under the system temporary directory, usually at `/tmp/lyp`. These include wrapper files, git repositories for installed packages, Lilypond archive files etc. These will normally be cleaned up by the OS after a period of time, but you can use this command to delete the entire content of this directory if you need the disk space.
+
+### lyp compile
+
+Synopsis: `lyp compile ... FILE`
+
+Shorthand: `lyp c`
+
+Compiles Lilypond source files. This command is synonymous to running `lilypond`. You can pass along any switches accepted by Lilypond. In addition, lyp adds a few options to provide additional functionality:
+
+- `--auto-install-deps`/`-a`: install any missing dependencies
+- `--cropped`/`-c`: crop output (requires setting 0 margins)
+- `--env`/`-E`: use the Lilypond version specified in the `LILYPOND_VERSION` environment variable:
+
+  ```bash
+  $ LILYPOND_VERSION=2.19.50 lyp c mysuperscore.ly
+  ```
+
+- `--force-version`/`-F`: use Lilypond version specified in user file
+- `--install`/`-n`: install version of Lilypond if not found (if the required version was overriden using any of `--env`, `--force-version` or `--use`)
+- `--open`/`-O`: open output file after compilation
+- `--raw`/`-R`: run Lilypond "raw" (no pre-processing of dependencies)
+- `--require=PACKAGE`/`-rPACKAGE`: preload the specified package
+
+  ```bash
+  $ lyp -rassert mytests.ly
+  ```
+
+- `--snippet`/`-S`: produce png cropped images at 600dpi (equivalent to `--cropped --png -dresolution=600`)
+- `--use=VERSION`/`-uVERSION`: use the given version of Lilypond:
+  
+  ```bash
+  $ lyp c -u2.19.53 myfile.ly
+  # automatically install given version of Lilypond
+  $ lyp c -nu2.19.53 myfile.ly
+  ```
+
+### lyp deps
+
+Synopsis: `lyp deps FILE`
+
+Shows dependencies for a given source file.
+
+### lyp exec
+
+Synopsis: `lyp exec SCRIPT ...`
+
+Shorthand: `lyp x`
+
+Runs a Lilypond script (using the currently selected version of Lilypond).
+
+### lyp flatten
+
+Synopsis: `lyp flatten FILE`
+
+Flattens a source file and all included files into a single file.
+
+### lyp install
+
+Synopsis: `lyp install PACKAGE|lilypond@VERSION`
+
+Shorthand: `lyp i`
+
+Installs a package or a Lilypond. See [installing packages](#installing-packages) and [installing versions of Lilypond](#installing-and-using-lilypond) above.
+
+### lyp list
+
+Synopsis: `lyp list [PACKAGE|lilypond]`
+
+Shorthand: `lyp l`
+
+Lists installed packages or Lilyponds.
+
+### lyp resolve
+
+Synopsis: `lyp resolve FILE``
+
+Resolves and optionally installs all dependencies for a given source file. To install required dependencies use the `--all`/`-a` switch:
+
+```bash
+$ lyp resolve -a myfile.ly
+```
+
+### lyp search
+
+Synopsis: `lyp search PACKAGE|lilypond``
+
+Shorthand: `lyp s`
+
+Searches for packages or versions of Lilypond.
+
+### lyp test
+
+Synopsis: `lyp test DIRECTORY`
+
+Shorthand: `lyp t`
+
+Runs Lilypond tests by compiling all files in the given directory matching the pattern `*-test.ly`.
+
+### lyp uninstall
+
+Synopsis: `lyp uninstall PACKAGE|lilypond@VERSION`
+
+Shorthand: `lyp u`
+
+Uninstalls a package or a Lilypond.
+
+### lyp update
+
+Synopsis: `lyp update PACKAGE`
+
+Updates an installed package to its latest available version.
+
+### lyp use
+
+Synopsis: `lyp use VERSION``
+
+Shorthand: `lyp U`
+
+Switches to a different version of Lilypond. To set the default version, use the `--default` switch:
+
+```bash
+$ lyp use --default 2.19.52
+```
+
+### lyp version
+
+Synopsis: `lyp version``
+
+Shorthand: `lyp -v``
+
+Displays the version of lyp.
+
+### lyp watch
+
+Synopsis: `lyp watch DIRECTORY|FILE...``
+
+Shorthand: `lyp w`
+
+Watches one or more directories or files and recompiles any files that have been modified. To watch a directory of include files and always recompile the same project file, use the `--target`/`-t` switch:
+
+```bash
+$ lyp watch bwv35 --target bwv35/score.ly
+```
+
+This command accepts all Lilypond command line switches.
+
+### lyp which
+
+Synopsis: `lyp which PACKAGE|lilypond`
+
+Shows the location of the given package or the currently selected Lilypond.
+
 ## Contributing
 
 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:

data/bin/install_release.sh

@@ -1,6 +1,15 @@
 #!/usr/bin/env bash
 
-LYP_VERSION="1.2.1"
+echo "Detecting latest lyp version..."
+LATEST_RELEASE=`curl -s https://github.com/noteflakes/lyp/releases/latest`
+VERSION_REGEX="tag/v([0-9\.]+)"
+if [[ $LATEST_RELEASE =~ $VERSION_REGEX ]]
+then
+  LYP_VERSION="${BASH_REMATCH[1]}"
+else
+  echo "Could not get latest version from GitHub."
+fi
+
 WORKDIR="/tmp/lyp-release-installer"
 URL_BASE="https://github.com/noteflakes/lyp/releases/download/v$LYP_VERSION"
 

data/lib/lyp.rb

@@ -1,23 +1,24 @@
-def req_int(f)
-  require File.expand_path("lyp/#{f}", File.dirname(__FILE__))
-end
-
 module Kernel
   @@ext_requires = {}
   def req_ext(l)
     @@ext_requires[l] ||= require(l)
   end
-end 
 
-req_int 'base'
-req_int 'system'
-req_int 'settings'
+  LYP_RB_DIR = File.expand_path("lyp", File.dirname(__FILE__))
+  def req_int(f)
+    require File.join(LYP_RB_DIR, f)
+  end
+end
+
+Kernel.req_int 'base'
+Kernel.req_int 'system'
+Kernel.req_int 'settings'
 
-req_int 'template'
-req_int 'resolver'
-req_int 'wrapper'
-req_int 'package'
-req_int 'lilypond'
-req_int 'transform'
+Kernel.req_int 'template'
+Kernel.req_int 'resolver'
+Kernel.req_int 'wrapper'
+Kernel.req_int 'package'
+Kernel.req_int 'lilypond'
+Kernel.req_int 'transform'
 
-req_int 'windows' if Lyp::WINDOWS
+Kernel.req_int 'windows' if Lyp::WINDOWS

data/lib/lyp/cli.rb

@@ -43,29 +43,20 @@ $cmd_options = {}
 
 class Lyp::CLI < Thor
   package_name "lyp"
-  map "-v" => :version
-  check_unknown_options! :except => :compile
+  map "-v" => :version,
+      "c" => :compile,
+      "i" => :install,
+      "l" => :list,
+      "s" => :search,
+      "t" => :test,
+      "u" => :uninstall,
+      "U" => :use,
+      "w" => :watch,
+      "x" => :exec
+
+  check_unknown_options! :except => [:compile, :watch, :benchmark]
   class_option :verbose, aliases: '-V', :type => :boolean, desc: 'show verbose output'
 
-  desc "version", "show Lyp version"
-  def version
-    $stderr.puts "Lyp #{Lyp::VERSION}"
-  end
-
-  desc "search [PATTERN|lilypond]", "List available packages matching PATTERN or versions of lilypond"
-  def search(pattern = '')
-    $cmd_options = options
-
-    pattern =~ Lyp::PACKAGE_RE
-    package, version = $1, $2
-
-    if package == 'lilypond'
-      search_lilypond(version)
-    else
-      search_package(pattern)
-    end
-  end
-
   no_commands do
     def search_lilypond(version)
       versions = Lyp::Lilypond.search(version)
@@ -99,17 +90,68 @@ class Lyp::CLI < Thor
     end
   end
 
-  desc "compile [<option>...] <FILE>", "Invoke lilypond with given file"
+  desc "accelerate", "Rewrite gem binaries to make lyp faster"
+  def accelerate
+    unless Lyp::System.is_gem?
+      puts "Lyp is not installed as a gem."
+      exit 1
+    end
+
+    Lyp::System.rewrite_gem_scripts
+  end
+
+  desc "benchmark FILE", "Benchmark all installed versions of Lilypond"
+  def benchmark(*argv)
+    list = Lyp::Lilypond.list
+    if list.empty?
+      puts Lyp::LILYPOND_NOT_FOUND_MSG
+    else
+      list.each do |info|
+        Lyp::Lilypond.force_version!(info[:version])
+        t1 = Time.now
+        compile("--invoke-quiet", *argv)
+        t2 = Time.now
+        puts "%-7s: %.3gs" % [info[:version], t2-t1]
+      end
+    end
+  end
+
+  desc "cleanup", "Cleanup temporary files"
+  def cleanup
+    $stderr.puts "Lyp #{Lyp::VERSION}"
+    Dir["#{Lyp::TMP_ROOT}/*"].each do |fn|
+      puts "Cleaning up #{fn}"
+      FileUtils.rm_rf(fn)
+    end
+  end
+
+  desc "compile [<option>...] <FILE>", "compile given file Lilypond source file"
   def compile(*argv)
     opts, argv = Lyp::Lilypond.preprocess_argv(argv)
 
     lilypond_path = Lyp::Lilypond.select_lilypond_version(opts, argv.last)
 
-    $stderr.puts "Lyp #{Lyp::VERSION}"
+    $stderr.puts "Lyp #{Lyp::VERSION}" unless opts[:mode] == :quiet
     Lyp::System.test_installed_status!
     Lyp::Lilypond.compile(argv, opts)
   end
 
+  desc "deps FILE", "List dependencies found in user's files"
+  def deps(fn)
+    $cmd_options = options
+
+    resolver = Lyp::DependencyResolver.new(fn)
+    tree = resolver.compile_dependency_tree(ignore_missing: true)
+    tree.dependencies.each do |package, spec|
+      versions = spec.versions.keys.map {|k| k =~ Lyp::PACKAGE_RE; $2 }.sort
+      if versions.empty?
+        puts "   #{spec.clause} => (no local version found)"
+      else
+        puts "   #{spec.clause} => #{versions.join(', ')}"
+      end
+    end
+  end
+
   desc "exec <CMD> [<options>...]", "Execute a lilypond script"
   def exec(*argv)
     $stderr.puts "Lyp #{Lyp::VERSION}"
@@ -117,38 +159,15 @@ class Lyp::CLI < Thor
     Lyp::Lilypond.invoke_script(argv, {})
   end
 
-  desc "test [<option>...] [.|PATTERN]", "Run package tests on installed packages or local directory"
-  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)
-    $cmd_options = options
-    test_opts = options.dup
-
-    if test_opts[:env]
-      unless ENV['LILYPOND_VERSION']
-        STDERR.puts "$LILYPOND_VERSION not set"
-        exit 1
-      end
-      test_opts[:use] = ENV['LILYPOND_VERSION']
-    end
-
-    if test_opts[:use]
-      if test_opts[:install]
-        Lyp::Lilypond.install_if_missing(test_opts[:use], no_version_test: true)
-      end
-      Lyp::Lilypond.force_version!(test_opts[:use])
-    end
-
-    # check lilypond default / current settings
-    Lyp::Lilypond.check_lilypond!
-
-    $stderr.puts "Lyp #{Lyp::VERSION}"
-    case args
-    when ['.']
-      Lyp::Package.run_local_tests('.')
+  desc "flatten FILE", "Flatten a file and included files into a single output file"
+  def flatten(input_path, output_path = nil)
+    input_path = File.expand_path(input_path)
+    output_path = File.expand_path(output_path) if output_path
+    flat = Lyp::Transform.flatten(input_path)
+    if output_path
+      File.open(output_path, 'w+') {|f| f << flat}
     else
-      Lyp::Package.run_package_tests(args)
+      puts flat
     end
   end
 
@@ -184,50 +203,6 @@ class Lyp::CLI < Thor
     end
   end
 
-  desc "update <PACKAGE>...", "Install a package after removing all previous versions"
-  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 update(*args)
-    invoke 'install', args, options.merge(update: true)
-  end
-
-  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?
-    args.each do |package|
-      case package
-      when 'self'
-        Lyp::System.uninstall!
-      when Lyp::LILYPOND_RE
-        Lyp::System.test_installed_status!
-        Lyp::Lilypond.uninstall($1, options)
-      else
-        Lyp::System.test_installed_status!
-        Lyp::Package.uninstall(package, options)
-      end
-    end
-  end
-
-  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
-      version = $1
-    end
-
-    lilypond = Lyp::Lilypond.use(version, options)
-    puts "Using Lilypond version #{lilypond[:version]}"
-  end
-
   desc "list [PATTERN|lilypond]", "List installed packages matching PATTERN or versions of Lilypond"
   def list(pattern = nil)
     $cmd_options = options
@@ -265,83 +240,174 @@ class Lyp::CLI < Thor
     end
   end
 
-  desc "which [PATTERN|lilypond]", "List locations of installed packages matching PATTERN or versions of Lilypond"
-  def which(pattern = nil)
+  desc "resolve FILE", "Resolve and install 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
 
-    Lyp::System.test_installed_status!
+    resolver = Lyp::DependencyResolver.new(fn)
+    tree = resolver.compile_dependency_tree(ignore_missing: true)
+    tree.dependencies.each do |package, spec|
+      if options[:all] || spec.versions.empty?
+        Lyp::Package.install(spec.clause)
+      end
+    end
+  end
 
-    if pattern == 'lilypond'
-      current = Lyp::Lilypond.current_lilypond
-      if current
-        puts Lyp::Lilypond.current_lilypond
-      else
-        puts Lyp::LILYPOND_NOT_FOUND_MSG
+  desc "search [PATTERN|lilypond]", "List available packages matching PATTERN or versions of lilypond"
+  def search(pattern = '')
+    $cmd_options = options
+
+    pattern =~ Lyp::PACKAGE_RE
+    package, version = $1, $2
+
+    if package == 'lilypond'
+      search_lilypond(version)
+    else
+      search_package(pattern)
+    end
+  end
+
+  desc "test [<option>...] [.|PATTERN]", "Run package tests on installed packages or local directory"
+  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)
+    $cmd_options = options
+    test_opts = options.dup
+
+    if test_opts[:env]
+      unless ENV['LILYPOND_VERSION']
+        STDERR.puts "$LILYPOND_VERSION not set"
+        exit 1
       end
+      test_opts[:use] = ENV['LILYPOND_VERSION']
+    end
+
+    if test_opts[:use]
+      if test_opts[:install]
+        Lyp::Lilypond.install_if_missing(test_opts[:use], no_version_test: true)
+      end
+      Lyp::Lilypond.force_version!(test_opts[:use])
+    end
+
+    # check lilypond default / current settings
+    Lyp::Lilypond.check_lilypond!
+
+    $stderr.puts "Lyp #{Lyp::VERSION}"
+    case args
+    when ['.']
+      Lyp::Package.run_local_tests('.')
     else
-      Lyp::Package.which(args.first).each {|p| puts p}
+      Lyp::Package.run_package_tests(args)
     end
   end
 
-  desc "deps FILE", "List dependencies found in user's files"
-  def deps(fn)
+  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
 
-    resolver = Lyp::DependencyResolver.new(fn)
-    tree = resolver.compile_dependency_tree(ignore_missing: true)
-    tree.dependencies.each do |package, spec|
-      versions = spec.versions.keys.map {|k| k =~ Lyp::PACKAGE_RE; $2 }.sort
-      if versions.empty?
-        puts "   #{spec.clause} => (no local version found)"
+    Lyp::System.test_installed_status!
+
+    raise "No package specified" if args.empty?
+    args.each do |package|
+      case package
+      when 'self'
+        Lyp::System.uninstall!
+      when Lyp::LILYPOND_RE
+        Lyp::System.test_installed_status!
+        Lyp::Lilypond.uninstall($1, options)
       else
-        puts "   #{spec.clause} => #{versions.join(', ')}"
+        Lyp::System.test_installed_status!
+        Lyp::Package.uninstall(package, options)
       end
     end
   end
 
-  desc "resolve FILE", "Resolve and install missing dependencies found in user's files"
-  method_option :all, aliases: '-a', type: :boolean, desc: 'Install all found dependencies'
-  def resolve(fn)
+  desc "update <PACKAGE>...", "Install a package after removing all previous versions"
+  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 update(*args)
+    invoke 'install', args, options.merge(update: true)
+  end
+
+  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
 
-    resolver = Lyp::DependencyResolver.new(fn)
-    tree = resolver.compile_dependency_tree(ignore_missing: true)
-    tree.dependencies.each do |package, spec|
-      if options[:all] || spec.versions.empty?
-        Lyp::Package.install(spec.clause)
-      end
+    Lyp::System.test_installed_status!
+
+    if version =~ Lyp::LILYPOND_RE
+      version = $1
     end
+
+    lilypond = Lyp::Lilypond.use(version, options)
+    puts "Using Lilypond version #{lilypond[:version]}"
   end
 
-  desc "cleanup", "Cleanup temporary files"
-  def cleanup
+  desc "version", "show Lyp version"
+  def version
     $stderr.puts "Lyp #{Lyp::VERSION}"
-    Dir["#{Lyp::TMP_ROOT}/*"].each do |fn|
-      puts "Cleaning up #{fn}"
-      FileUtils.rm_rf(fn)
-    end
   end
 
-  desc "flatten FILE", "Flatten a file and included files into a single output file"
-  def flatten(input_path, output_path = nil)
-    input_path = File.expand_path(input_path)
-    output_path = File.expand_path(output_path) if output_path
-    flat = Lyp::Transform.flatten(input_path)
-    if output_path
-      File.open(output_path, 'w+') {|f| f << flat}
-    else
-      puts flat
+  desc "watch PATH...", "Watch files and directories and recompile when a file changes"
+  method_option :target, aliases: '-t', type: :string, desc: 'Set compile target'
+  def watch(*paths)
+    req_ext "directory_watcher"
+
+    recompile_proc = lambda do |path|
+      puts "#{path} changed"
+      path = options[:target] || path
+      puts "recompile #{path}"
+      if path =~ /\.(i?)ly$/
+        compile("--invoke-system", path)
+      end
     end
-  end
 
-  desc "accelerate", "Rewrite gem binaries to make lyp faster"
-  def accelerate
-    unless Lyp::System.is_gem?
-      puts "Lyp is not installed as a gem."
-      exit 1
+    target = options[:target]
+
+    watchers = paths.map do |path|
+      if File.directory?(path)
+        glob = ["**/*.ly", "**/*.ily", "**/*.scm"]
+      else
+        glob = [File.basename(path)]
+        path = File.dirname(path)
+      end
+
+      puts "Watching #{path}"
+      puts "glob: #{glob.inspect}"
+      w = DirectoryWatcher.new(path, glob: glob, pre_load: true).tap do |w|
+        w.interval = 0.1
+        w.add_observer do |*events|
+          events.each {|e| recompile_proc[e.path] if e.type == :modified}
+        end
+        w.start
+      end
     end
 
-    Lyp::System.rewrite_gem_scripts
+    trap("INT") {watchers.each {|w| w.stop}; puts; exit}
+    puts "Press ^C to exit"
+    loop {sleep 1}
+  end
+
+  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'
+      current = Lyp::Lilypond.current_lilypond
+      if current
+        puts Lyp::Lilypond.current_lilypond
+      else
+        puts Lyp::LILYPOND_NOT_FOUND_MSG
+      end
+    else
+      Lyp::Package.which(args.first).each {|p| puts p}
+    end
   end
 
   def self.run

data/lib/lyp/lilypond.rb

@@ -52,6 +52,10 @@ module Lyp::Lilypond
         options[:use_version] = argv.shift
       when /^(?:\-u|\-\-use\=)"?([^\s]+)"?/
         options[:use_version] = $1
+      when '--invoke-system'
+        options[:mode] = :system
+      when '--invoke-quiet'
+        options[:mode] = :quiet
       else
         argv_clean << arg
       end
@@ -108,6 +112,8 @@ module Lyp::Lilypond
       case opts[:mode]
       when :system
         system("#{lilypond} #{argv.join(" ")}")
+      when :quiet
+        `#{lilypond} #{argv.join(" ")} > /dev/null 2>&1`
       when :spawn
         pid = spawn(lilypond, *argv, opts[:spawn_opts] || {})
         Process.detach(pid)

data/lib/lyp/version.rb

@@ -1,3 +1,3 @@
 module Lyp
-  VERSION = "1.2.1"
+  VERSION = "1.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lyp
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-21 00:00:00.000000000 Z
+date: 2016-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient
@@ -84,6 +84,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 0.23.0
+- !ruby/object:Gem::Dependency
+  name: directory_watcher
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.1
 description: Lyp is a tool for managing lilypond versions and lilypond packages
 email: ciconia@gmail.com
 executables: