lyp-win 0.3.7 → 0.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 584894c8ae6df54e931da4b456f68a6b020b9894
-  data.tar.gz: 0305882ebc3ec0aee3a484f4bbea47cc39c6ccc1
+  metadata.gz: d825136da4c3e2bd0a2210a15d72ef1fe52550fe
+  data.tar.gz: 76479742a263932ee35c1189a9322c1eba6228fe
 SHA512:
-  metadata.gz: 4666c03f0fe3ea3df079ef71d175b80a4dbc3103814ad660c92d380f166849363c142cd3f295c39d414654d7a2c122fc15f2b3b86c528ecca806aa3d7eeb8fae
-  data.tar.gz: 318b2daf11c8507e082ee493b91a4f5d79f0b9c6bc55048b4db2a07be36a6ac6489bf347cd05de71aca4e0b6b374c66f143349a87c75a597913074d155631c89
+  metadata.gz: 18f12a5af72114378c619b5b52fe323c3b698751421bc857887b0fe40d1d1b0f98317f1beee3eb7b91e869ff9a99df8342504e55d109809002ad8a8e66e98d95
+  data.tar.gz: 867f9110f70f15b6d0417344401425a8f4f6b018224649de4b1f39aa2c5ef1d49022456b174c46c451183fc9790b39edd514b20002fad62b7a82662c194dfda5

data/bin/lilypond

@@ -19,10 +19,12 @@ OVERRIDING_LILYPOND_SWITCHES = %w{
   scheme-sandbox
 }
 LILYPOND_HELP_SWITCHES = %w{
-  -h --help
+  -h --help -dhelp
 }
+
 LYP_LY_HELP = <<EOF
 Lyp-provided options:
+  -c, --cropped                       crop output (requires setting 0 margins)
   -E, --env                           use version specified in $LILYPOND_VERSION
   -n, --install                       install the specified version if not found
   -O, --open                          open the target file after compilation
@@ -39,7 +41,7 @@ when nil, *OVERRIDING_LILYPOND_SWITCHES
 when *LILYPOND_HELP_SWITCHES
   STDERR.puts "Lyp version #{Lyp::VERSION}"
   puts `#{$lilypond_path} #{$argv.join(' ')}`
-  puts LYP_LY_HELP
+  puts LYP_LY_HELP unless $argv.first == '-dhelp'
 else
   begin
     Lyp::Lilypond.compile($argv, $options)

data/lib/lyp/cli.rb

@@ -46,30 +46,30 @@ class Lyp::CLI < Thor
   map "-v" => :version
   check_unknown_options! :except => :compile
   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)
-  
+
       if versions.empty?
         puts "\nNo available versions of lilypond@#{version} found\n\n"
       else
@@ -81,9 +81,9 @@ class Lyp::CLI < Thor
         puts "\n * Currently installed\n\n"
       end
     end
-    
+
     PACKAGE_FMT = "%-16s => %s"
-  
+
     def search_package(pattern)
       packages = Lyp::Package.list_lyp_index(pattern)
       if packages.empty?
@@ -109,7 +109,7 @@ class Lyp::CLI < Thor
     Lyp::System.test_installed_status!
     Lyp::Lilypond.compile(argv, opts)
   end
-  
+
   desc "test [<option>...] [.|PATTERN]", "Runs 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'
@@ -124,7 +124,7 @@ class Lyp::CLI < Thor
       end
       options[:use] = ENV['LILYPOND_VERSION']
     end
-    
+
     if options[:use]
       if options[:install]
         Lyp::Lilypond.install_if_missing(options[:use], no_version_test: true)
@@ -134,7 +134,7 @@ class Lyp::CLI < Thor
 
     # check lilypond default / current settings
     Lyp::Lilypond.check_lilypond!
-    
+
     $stderr.puts "Lyp #{Lyp::VERSION}"
     case args
     when ['.']
@@ -151,7 +151,7 @@ class Lyp::CLI < Thor
     $cmd_options = options
 
     raise "No package specified" if args.empty?
-    
+
     args.each do |package|
       case package
       when 'self'
@@ -187,7 +187,7 @@ class Lyp::CLI < Thor
       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)
@@ -198,7 +198,7 @@ class Lyp::CLI < Thor
     if version =~ Lyp::LILYPOND_RE
       version = $1
     end
-  
+
     lilypond = Lyp::Lilypond.use(version, options)
     puts "Using lilypond version #{lilypond[:version]}"
   end
@@ -227,11 +227,11 @@ class Lyp::CLI < Thor
           return puts "\nNo packages are currently installed\n\n"
         end
       end
-      
+
       by_package = list.inject({}) do |m, p|
         p =~ Lyp::PACKAGE_RE; (m[$1] ||= []) << $2; m
       end
-      
+
       puts "\nInstalled packages:\n\n"
       by_package.keys.sort.each do |p|
         puts "   #{p} => (#{by_package[p].sort.join(', ')})"
@@ -239,7 +239,7 @@ class Lyp::CLI < Thor
       puts "\n\n"
     end
   end
-  
+
   desc "which [PATTERN|lilypond]", "List locations of installed packages matching PATTERN or versions of lilypond"
   def which(pattern = nil)
     $cmd_options = options
@@ -257,37 +257,46 @@ class Lyp::CLI < Thor
       Lyp::Package.which(args.first).each {|p| puts p}
     end
   end
-  
+
   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|
-      versions = leaf[:versions].keys.map {|k| k =~ Lyp::PACKAGE_RE; $2 }.sort
+    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 "   #{leaf[:clause]} => (no local version found)"
+        puts "   #{spec.clause} => (no local version found)"
       else
-        puts "   #{leaf[:clause]} => #{versions.join(', ')}"
+        puts "   #{spec.clause} => #{versions.join(', ')}"
       end
     end
   end
-  
+
   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|
-      if options[:all] || leaf[:versions].empty?
-        Lyp::Package.install(leaf[:clause])
+    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
-  
+
+  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
+
   def self.run
     start(ARGV)
   rescue => e
@@ -296,4 +305,3 @@ class Lyp::CLI < Thor
     exit(1)
   end
 end
-

data/lib/lyp/lilypond.rb

@@ -32,6 +32,8 @@ module Lyp::Lilypond
           options[:install] = true
         when '-O', '--open'
           options[:open] = true
+        when '-c', '--cropped'
+          argv_clean += ['-dbackend=eps', '-daux-files=#f']
         else
           argv_clean << arg
         end
@@ -39,7 +41,7 @@ module Lyp::Lilypond
 
       [options, argv_clean]
     end
-    
+
     def select_lilypond_version(opts)
       if opts[:use_version]
         if opts[:install]
@@ -58,19 +60,19 @@ module Lyp::Lilypond
       STDERR.puts e.message
       exit 1
     end
-    
+
     def compile(argv, opts = {})
       unless argv.last == '-'
         fn = Lyp.wrap(argv.pop, opts)
         argv << fn
       end
-      
+
       invoke(argv, opts)
     end
-    
+
     def invoke(argv, opts = {})
       lilypond = current_lilypond
-      
+
       case opts[:mode]
       when :system
         system("#{lilypond} #{argv.join(" ")}")
@@ -78,30 +80,30 @@ module Lyp::Lilypond
         Kernel.exec(lilypond, *argv)
       end
     end
-    
+
     def default_lilypond
       Lyp::Settings['lilypond/default']
     end
-    
+
     def set_default_lilypond(path)
       Lyp::Settings['lilypond/default'] = path
     end
-    
-    # The current lilypond path is stored in a temporary file named by the 
+
+    # The current lilypond path is stored in a temporary file named by the
     # session id. Thus we can persist the version selected by the user
     def current_lilypond
       return forced_lilypond if @forced_version
-      
+
       settings = get_session_settings
 
       if !settings[:current]
         settings[:current] = default_lilypond
         set_session_settings(settings)
       end
-      
+
       settings[:current]
     end
-    
+
     def current_lilypond_version
       path = current_lilypond
       version = File.basename(File.expand_path("#{File.dirname(path)}/../.."))
@@ -114,13 +116,13 @@ module Lyp::Lilypond
       end
       version
     end
-    
+
     def set_current_lilypond(path)
       settings = get_session_settings
       settings[:current] = path
       set_session_settings(settings)
     end
-    
+
     def forced_lilypond
       lilypond = filter_installed_list(@forced_version)[0]
       if lilypond
@@ -129,32 +131,32 @@ module Lyp::Lilypond
         raise "No installed version found matching '#{@forced_version}'"
       end
     end
-    
+
     def force_env_version!
       @forced_version = ENV['LILYPOND_VERSION']
       unless @forced_version
         raise "LILYPOND_VERSION not set"
       end
     end
-    
+
     def force_version!(version)
       @forced_version = version
     end
-    
+
     attr_reader :forced_version
-    
+
     def check_lilypond!
       path = default_lilypond
       select_default_lilypond! unless path && path =~ /lilypond$/
-      
+
       path = current_lilypond
       set_current_lilypond(default_lilypond) unless path && path =~ /lilypond$/
     end
-    
+
     def valid_lilypond?(path)
       (File.file?(path) rescue nil) && (`#{path} -v` =~ /^GNU LilyPond/)
     end
-    
+
     def select_default_lilypond!
       latest = system_lilyponds.sort(&CMP_VERSION).last || lyp_lilyponds.sort(&CMP_VERSION).last
       if latest
@@ -164,34 +166,34 @@ module Lyp::Lilypond
         raise Lyp::LILYPOND_NOT_FOUND_MSG
       end
     end
-    
+
     def get_session_settings
       YAML.load(IO.read(session_settings_filename)) rescue {}
     end
-    
+
     def set_session_settings(settings)
       File.open(session_settings_filename, 'w+') do |f|
         f << YAML.dump(settings)
       end
     end
-    
+
     def session_settings_filename
       "#{Lyp::TMP_ROOT}/session.#{Process.getsid}.yml"
     end
-    
+
     CMP_VERSION = proc do |x, y|
       Gem::Version.new(x[:version]) <=> Gem::Version.new(y[:version])
     end
-    
+
     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
         latest = system_list.sort(&CMP_VERSION).last || lyp_list.sort(&CMP_VERSION).last
@@ -201,24 +203,24 @@ module Lyp::Lilypond
         end
       end
       current = current_lilypond
-      
+
       lilyponds = system_list + lyp_list
 
       lilyponds.each do |l|
         l[:default] = l[:path] == default
         l[:current] = l[:path] == current
       end
-      
+
       # sort by version
       lilyponds.sort!(&CMP_VERSION)
     end
-    
+
     def lyp_lilyponds
       list = []
-      
+
       Dir["#{Lyp.lilyponds_dir}/*"].each do |path|
         next unless File.directory?(path) && File.basename(path) =~ /^[\d\.]+$/
-        
+
         root_path = path
         version = File.basename(path)
         path = File.join(path, "bin/lilypond")
@@ -229,14 +231,14 @@ module Lyp::Lilypond
           version: version
         }
       end
-      
+
       list
     end
-    
+
     def system_lilyponds
       list = get_system_lilyponds_paths
       return list if list.empty?
-      
+
       list.inject([]) do |m, path|
         begin
           resp = `#{path} #{Lyp::DETECT_SYSTEM_LILYPOND_FILENAME} 2>/dev/null`
@@ -257,32 +259,32 @@ module Lyp::Lilypond
         m
       end
     end
-    
+
     def get_system_lilyponds_paths
       self_bin_dir = File.dirname(File.expand_path($0))
-      
+
       list = `which -a lilypond`
       list = list.lines.map {|f| f.chomp}.uniq.reject do |l|
         dir = File.dirname(l)
         (dir == Gem.bindir) || (dir == Lyp::LYP_BIN_DIRECTORY) || (dir == self_bin_dir)
       end
     end
-    
+
     BASE_URL = "http://download.linuxaudio.org/lilypond/binaries"
-  
+
     # Returns a list of versions of lilyponds available for download
     def search(version_specifier = nil)
       require 'open-uri'
 
       platform = detect_lilypond_platform
       url = "#{BASE_URL}/#{platform}/"
-      
+
       versions = []
-      
-      open(url).read.scan(/a href=\"lilypond-([0-9\.]+)[^>]+\"/) do |m|        
+
+      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)}
       versions.map do |v|
@@ -292,7 +294,7 @@ module Lyp::Lilypond
         }
       end
     end
-    
+
     def version_match(version, specifier, all_versions)
       case specifier
       when 'latest'
@@ -305,29 +307,29 @@ module Lyp::Lilypond
         Gem::Requirement.new(specifier) =~ Gem::Version.new(version)
       end
     end
-    
+
     def latest_stable_version
       search.reverse.find {|l| Gem::Version.new(l[:version]).segments[1].even?}[:version]
     end
-    
+
     def latest_unstable_version
       search.reverse.find {|l| Gem::Version.new(l[:version]).segments[1].odd?}[:version]
     end
-    
+
     def latest_version
       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
-      
+
       STDERR.puts "Installing version #{version}" unless opts[:silent]
       install_version(version, opts)
 
@@ -335,11 +337,11 @@ module Lyp::Lilypond
       set_current_lilypond(lilypond_path)
       set_default_lilypond(lilypond_path) if opts[:default]
     end
-    
+
     def lyp_lilypond_path(version)
       "#{Lyp.lilyponds_dir}/#{version}/bin/lilypond"
     end
-    
+
     def detect_version_from_specifier(version_specifier)
       case version_specifier
       when /^\d/
@@ -360,7 +362,7 @@ module Lyp::Lilypond
         end
       end
     end
-    
+
     def detect_lilypond_platform
       case RUBY_PLATFORM
       when /x86_64-darwin/
@@ -377,7 +379,7 @@ module Lyp::Lilypond
         "mingw"
       end
     end
-  
+
     def install_version(version, opts)
       platform = detect_lilypond_platform
       url = lilypond_install_url(platform, version, opts)
@@ -385,7 +387,7 @@ module Lyp::Lilypond
 
       download_lilypond(url, fn, opts) unless File.file?(fn)
       install_lilypond_files(fn, platform, version, opts)
-      
+
       patch_font_scm(version)
       copy_fonts_from_all_packages(version, opts)
     end
@@ -400,15 +402,15 @@ module Lyp::Lilypond
         ".exe"
       end
       filename = "lilypond-#{version}-1.#{platform}"
-    
+
       "#{BASE_URL}/#{platform}/#{filename}#{ext}"
     end
-    
+
     def temp_install_filename(url)
       u = URI(url)
       "#{Lyp::TMP_ROOT}/#{File.basename(u.path)}"
     end
-  
+
     def download_lilypond(url, fn, opts)
       require 'httpclient'
 
@@ -435,7 +437,7 @@ module Lyp::Lilypond
       end
       pbar.finish unless opts[:silent]
     end
-  
+
     def install_lilypond_files(fn, platform, version, opts)
       tmp_target = "#{Lyp::TMP_ROOT}/lilypond-#{version}"
       FileUtils.mkdir_p(tmp_target)
@@ -448,19 +450,19 @@ module Lyp::Lilypond
       when /mingw/
         install_lilypond_files_windows(fn, tmp_target, platform, version, opts)
       end
-      
+
     ensure
       FileUtils.rm_rf(tmp_target)
     end
-  
+
     def install_lilypond_files_osx(fn, target, platform, version, opts)
       STDERR.puts "Extracting..." unless opts[:silent]
       exec "tar -xjf #{fn} -C #{target}"
-    
+
       copy_lilypond_files("#{target}/LilyPond.app/Contents/Resources", version, opts)
     end
-  
-    # Since linux versions are distributed as sh archives, we need first to 
+
+    # Since linux versions are distributed as sh archives, we need first to
     # extract the sh archive, then extract the resulting tar file
     def install_lilypond_files_linux(fn, target, platform, version, opts)
       STDERR.puts "Extracting..." unless opts[:silent]
@@ -468,30 +470,30 @@ module Lyp::Lilypond
       # create temp directory in which to extract .sh file
       tmp_dir = "#{Lyp::TMP_ROOT}/#{Time.now.to_f}"
       FileUtils.mkdir_p(tmp_dir)
-    
+
       FileUtils.cd(tmp_dir) do
         exec "sh #{fn} --tarball >/dev/null"
       end
-      
+
       tmp_fn = "#{tmp_dir}/lilypond-#{version}-1.#{platform}.tar.bz2"
-      
+
       exec "tar -xjf #{tmp_fn} -C #{target}"
-    
+
       copy_lilypond_files("#{target}/usr", version, opts)
     ensure
       FileUtils.rm_rf(tmp_dir)
     end
-    
+
     def install_lilypond_files_windows(fn, target, platform, version, opts)
       STDERR.puts "Running NSIS Installer..." unless opts[:silent]
-      
+
       target_dir = File.join(Lyp.lilyponds_dir, version)
       FileUtils.mkdir_p(target_dir)
-      
+
       # run installer
       cmd = "#{fn} /S /D=#{target_dir.gsub('/', '\\')}"
       `#{cmd}`
-      
+
       # wait for installer to finish
       t1 = Time.now
       while !File.file?("#{target_dir}/usr/bin/lilypond.exe")
@@ -505,44 +507,44 @@ module Lyp::Lilypond
 
     def copy_lilypond_files(base_path, version, opts)
       target_dir = File.join(Lyp.lilyponds_dir, version)
-      
+
       FileUtils.rm_rf(target_dir) if File.exists?(target_dir)
-      
+
       # create directory for lilypond files
       FileUtils.mkdir_p(target_dir)
-    
+
       # copy files
       STDERR.puts "Copying..." unless opts[:silent]
       %w{bin etc lib lib64 share var}.each do |entry|
         dir = File.join(base_path, entry)
         FileUtils.cp_r(dir, target_dir, remove_destination: true) if File.directory?(dir)
       end
-      
+
       # Show lilypond versions
       STDERR.puts `#{target_dir}/bin/lilypond -v` unless opts[:silent] || opts[:no_version_test]
     rescue => e
       puts e.message
     end
-    
+
     def patch_font_scm(version)
       return unless Lyp::FONT_PATCH_REQ =~ Gem::Version.new(version)
-      
+
       target_fn = File.join(lyp_lilypond_share_dir(version), 'lilypond/current/scm/font.scm')
       FileUtils.cp(Lyp::FONT_PATCH_FILENAME, target_fn)
     end
 
     SYSTEM_LILYPOND_PATCH_WARNING = <<-EOF.gsub(/^\s{6}/, '').chomp
-      The system-installed lilypond version %s needs to be patched in 
+      The system-installed lilypond version %s needs to be patched in
       order to support custom music fonts. This operation will replace the file
-      
+
         %s
-      
-      Would you like to overwrite this file? (y/n): 
+
+      Would you like to overwrite this file? (y/n):
     EOF
-    
+
     def patch_system_lilypond_font_scm(lilypond, opts)
       return false unless Lyp::FONT_PATCH_REQ =~ Gem::Version.new(lilypond[:version])
-      
+
       target_fn = File.join(lilypond[:data_path], '/scm/font.scm')
       # do nothing if alredy patched
       if IO.read(target_fn) == IO.read(Lyp::FONT_PATCH_FILENAME)
@@ -551,7 +553,7 @@ module Lyp::Lilypond
 
       prompt = SYSTEM_LILYPOND_PATCH_WARNING % [lilypond[:version], target_fn]
       return unless Lyp.confirm_action(prompt)
-      
+
       puts "Patching #{target_fn}:" unless opts[:silent]
       if File.writeable?(target_fn)
         FileUtils.cp(target_fn, "#{target_fn}.old")
@@ -561,38 +563,38 @@ module Lyp::Lilypond
         Lyp.sudo_cp(Lyp::FONT_PATCH_FILENAME, target_fn)
       end
     end
-    
+
     def copy_fonts_from_all_packages(version, opts)
       return unless Lyp::FONT_COPY_REQ =~ Gem::Version.new(version)
-      
+
       ly_fonts_dir = File.join(lyp_lilypond_share_dir(version), 'lilypond/current/fonts')
-      
+
       Dir["#{Lyp.packages_dir}/**/fonts"].each do |package_fonts_dir|
 
         Dir["#{package_fonts_dir}/*.otf"].each do |fn|
           target_fn = File.join(ly_fonts_dir, 'otf', File.basename(fn))
           FileUtils.cp(fn, target_fn)
         end
-        
+
         Dir["#{package_fonts_dir}/*.svg"].each do |fn|
           target_fn = File.join(ly_fonts_dir, 'svg', File.basename(fn))
           FileUtils.cp(fn, target_fn)
         end
-        
+
         Dir["#{package_fonts_dir}/*.woff"].each do |fn|
           target_fn = File.join(ly_fonts_dir, 'svg', File.basename(fn))
           FileUtils.cp(fn, target_fn)
         end
       end
     end
-    
+
     def lyp_lilypond_share_dir(version)
       File.join(Lyp.lilyponds_dir, version, 'share')
     end
-    
+
     def use(version, opts)
       lilypond_list = list.reverse
-      
+
       case version
       when 'system'
         lilypond = lilypond_list.find {|v| v[:system] }
@@ -614,17 +616,17 @@ module Lyp::Lilypond
         req = Gem::Requirement.new(version)
         lilypond = lilypond_list.find {|v| req =~ Gem::Version.new(v[:version])}
       end
-      
+
       unless lilypond
         raise "Could not find a lilypond matching \"#{version}\""
       end
-      
+
       set_current_lilypond(lilypond[:path])
       set_default_lilypond(lilypond[:path]) if opts[:default]
-      
+
       lilypond
     end
-    
+
     def uninstall(version_specifier, opts = {})
       list = list(lyp_only: true)
       if version_specifier
@@ -633,7 +635,7 @@ module Lyp::Lilypond
         # if no version is specified
         raise "No version specifier given.\nTo uninstall all versions run 'lyp uninstall lilypond -a'.\n"
       end
-      
+
       if list.empty?
         if version_specifier
           raise "No lilypond found matching #{version_specifier}"
@@ -641,7 +643,7 @@ module Lyp::Lilypond
           raise "No lilypond found"
         end
       end
-      
+
       list.each do |l|
         puts "Uninstalling lilypond #{l[:version]}" unless opts[:silent]
         set_current_lilypond(nil) if l[:current]
@@ -649,11 +651,11 @@ module Lyp::Lilypond
         uninstall_lilypond_version(l[:root_path])
       end
     end
-    
+
     def uninstall_lilypond_version(path)
       FileUtils.rm_rf(path)
     end
-    
+
     def exec(cmd, raise_on_failure = true)
       $_out = ""
       $_err = ""
@@ -669,9 +671,9 @@ module Lyp::Lilypond
       end
       success
     end
-    
+
     def parse_error_msg(msg)
       (msg =~ /[^\n]+: error.+failed files: ".+"/m) ? $& : msg
     end
   end
-end
+end