lyp-win 0.2.2

data/lib/lyp/etc/font.scm

@@ -0,0 +1,296 @@
+;;;; This file is part of LilyPond, the GNU music typesetter.
+;;;;
+;;;; Copyright (C) 2004--2014 Han-Wen Nienhuys <hanwen@xs4all.nl>
+;;;;
+;;;; LilyPond is free software: you can redistribute it and/or modify
+;;;; it under the terms of the GNU General Public License as published by
+;;;; the Free Software Foundation, either version 3 of the License, or
+;;;; (at your option) any later version.
+;;;;
+;;;; LilyPond is distributed in the hope that it will be useful,
+;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;;; GNU General Public License for more details.
+;;;;
+;;;; You should have received a copy of the GNU General Public License
+;;;; along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+
+;; This file supplied by Abraham Leigh and used by lyp to patch lilypond 
+;; versions from 2.18.2 to 2.19.11 in order to support custom music fonts.
+
+;; TODO:
+;;
+;; lookup-font should be written in  C.
+;;
+
+;; We have a tree, where each level of the tree is a qualifier
+;; (eg. encoding, family, shape, series etc.)  this defines the levels
+;; in the tree.  The first one is encoding, so we can directly select
+;; between text or music in the first step of the selection.
+(define default-qualifier-order
+  '(font-encoding font-family font-shape font-series))
+
+(define-class <Font-tree-element>
+  ())
+
+(define-class <Font-tree-leaf> (<Font-tree-element>)
+  (default-size #:init-keyword #:default-size)
+  (size-vector  #:init-keyword #:size-vector))
+
+(define-class <Font-tree-node> (<Font-tree-element>)
+  (qualifier #:init-keyword #:qualifier  #:accessor font-qualifier)
+  (default #:init-keyword #:default #:accessor font-default)
+  (children #:init-keyword #:children #:accessor font-children))
+
+(define (make-font-tree-leaf size size-font-vector)
+  (make <Font-tree-leaf> #:default-size size #:size-vector size-font-vector))
+
+(define (make-font-tree-node
+         qualifier default)
+  (make <Font-tree-node>
+    #:qualifier qualifier
+    #:default default
+    #:children (make-hash-table 11)))
+
+(define-method (display (leaf <Font-tree-leaf>) port)
+  (for-each (lambda (x) (display x port))
+            (list
+             "#<Font-size-family:\n"
+             (slot-ref leaf 'default-size)
+             (slot-ref leaf 'size-vector)
+             "#>"
+             )))
+
+(define-method (display (node <Font-tree-node>) port)
+  (for-each
+   (lambda (x)
+     (display x port))
+   (list
+    "Font_node {\nqual: "
+    (font-qualifier node)
+    "(def: "
+    (font-default node)
+    ") {\n"))
+  (for-each
+   (lambda (x)
+     (display "\n")
+     (display (car x) port)
+     (display "=" port)
+     (display (cdr x) port))
+   (hash-table->alist (font-children node)))
+  (display "} }\n"))
+
+
+(define-method (add-font (node <Font-tree-node>) fprops size-family)
+  (define (assoc-delete key alist)
+    (assoc-remove! (list-copy alist) key))
+
+  (define (make-node fprops size-family)
+    (if (null? fprops)
+        (make-font-tree-leaf (car size-family) (cdr size-family))
+        (let* ((qual (next-qualifier default-qualifier-order fprops)))
+          (make-font-tree-node qual
+                               (assoc-get qual fprops)))))
+
+  (define (next-qualifier order props)
+    (cond
+     ((and (null? props) (null? order))
+      #f)
+     ((null? props) (car order))
+     ((null? order) (caar props))
+     (else
+      (if (assoc-get (car order) props)
+          (car order)
+          (next-qualifier (cdr order) props)))))
+
+  (let* ((q (font-qualifier node))
+         (d (font-default node))
+         (v (assoc-get q fprops d))
+         (new-fprops (assoc-delete q fprops))
+         (child (hashq-ref (slot-ref node 'children)
+                           v #f)))
+    (if (not child)
+        (begin
+          (set! child (make-node new-fprops size-family))
+          (hashq-set! (slot-ref node 'children) v child)))
+    (if (pair? new-fprops)
+        (add-font child new-fprops size-family))))
+
+(define-method (add-font (node <Font-tree-leaf>) fprops size-family)
+  (throw "must add to node, not leaf"))
+
+(define-method (g-lookup-font (node <Font-tree-node>) alist-chain)
+  (let* ((qual (font-qualifier node))
+         (def (font-default node))
+         (val (chain-assoc-get qual alist-chain def))
+         (desired-child (hashq-ref (font-children node) val)))
+
+    (if desired-child
+        (g-lookup-font desired-child alist-chain)
+        (g-lookup-font (hashq-ref (font-children node) def) alist-chain))))
+
+(define-method (g-lookup-font (node <Font-tree-leaf>) alist-chain)
+  node)
+
+;; two step call is handy for debugging.
+(define (lookup-font node alist-chain)
+  (g-lookup-font node alist-chain))
+
+;; TODO - we could actually construct this by loading all OTFs and
+;; inspecting their design size fields.
+(define-public feta-design-size-mapping
+  '((11 . 11.22)
+    (13 . 12.60)
+    (14 . 14.14)
+    (16 . 15.87)
+    (18 . 17.82)
+    (20 . 20)
+    (23 . 22.45)
+    (26 . 25.20)))
+
+;; Each size family is a vector of fonts, loaded with a delay.  The
+;; vector should be sorted according to ascending design size.
+(define-public (add-music-fonts node family name brace design-size-alist factor)
+  "Set up music fonts.
+
+Arguments:
+@itemize
+@item
+@var{node} is the font tree to modify.
+
+@item
+@var{family} is the family name of the music font.
+
+@item
+@var{name} is the basename for the music font.
+@file{@var{name}-<designsize>.otf} should be the music font,
+
+@item
+@var{brace} is the basename for the brace font.
+@file{@var{brace}-brace.otf} should have piano braces.
+
+@item
+@var{design-size-alist} is a list of @code{(rounded . designsize)}.
+@code{rounded} is a suffix for font filenames, while @code{designsize}
+should be the actual design size.  The latter is used for text fonts
+loaded through pango/@/fontconfig.
+
+@item
+@var{factor} is a size factor relative to the default size that is being
+used.  This is used to select the proper design size for the text fonts.
+@end itemize"
+  (for-each
+   (lambda (x)
+     (add-font node
+               (list (cons 'font-encoding (car x))
+                     (cons 'font-family family))
+               (cons (* factor (cadr x))
+                     (caddr x))))
+
+   `((fetaText ,(ly:pt 20.0)
+               ,(list->vector
+                 (map (lambda (tup)
+                        (cons (ly:pt (cdr tup))
+                              (format #f "~a-~a ~a"
+                                      name
+                                      (car tup)
+                                      (ly:pt (cdr tup)))))
+                      design-size-alist)))
+     (fetaMusic ,(ly:pt 20.0)
+                ,(list->vector
+                  (map (lambda (size-tup)
+                         (delay (ly:system-font-load
+                                 (format #f "~a-~a" name (car size-tup)))))
+                       design-size-alist
+                       )))
+     (fetaBraces ,(ly:pt 20.0)
+                 #(,(delay (ly:system-font-load
+                            (format #f "~a-brace" brace)))))
+     )))
+
+(define-public (add-pango-fonts node lily-family family factor)
+  ;; Synchronized with the `text-font-size' variable in
+  ;; layout-set-absolute-staff-size-in-module (see paper.scm).
+  (define text-font-size (ly:pt (* factor 11.0)))
+
+  (define (add-node shape series)
+    (add-font node
+              `((font-family . ,lily-family)
+                (font-shape . ,shape)
+                (font-series . ,series)
+                (font-encoding . latin1) ;; ugh.
+                )
+              `(,text-font-size
+                . #(,(cons
+                      (ly:pt 12)
+                      (ly:make-pango-description-string
+                       `(((font-family . ,family)
+                          (font-series . ,series)
+                          (font-shape . ,shape)))
+                       (ly:pt 12)))))))
+
+  (add-node 'upright 'normal)
+  (add-node 'caps 'normal)
+  (add-node 'upright 'bold)
+  (add-node 'italic 'normal)
+  (add-node 'italic 'bold))
+
+; This function allows the user to change the specific fonts, leaving others
+; to the default values. This way, "make-pango-font-tree"'s syntax doesn't
+; have to change from the user's perspective.
+;
+; Usage:
+;   \paper {
+;     #(define fonts
+;       (set-global-fonts
+;        #:music "gonville"  ; (the main notation font)
+;        #:roman "FreeSerif" ; (the main/serif text font)
+;       ))
+;   }
+;
+; Leaving out "#:brace", "#:sans", and "#:typewriter" leave them at 
+; "emmentaler", "sans-serif", and "monospace", respectively. All fonts are
+; still accesible through the usual scheme symbols: 'feta, 'roman, 'sans, and
+; 'typewriter.
+(define*-public (set-global-fonts #:key 
+  (music "emmentaler")
+  (brace "emmentaler")
+  (roman "Century Schoolbook L")
+  (sans "sans-serif")
+  (typewriter "monospace")
+  (factor 1))
+  (let ((n (make-font-tree-node 'font-encoding 'fetaMusic)))
+    (add-music-fonts n 'feta music brace feta-design-size-mapping factor)
+    (add-pango-fonts n 'roman roman factor)
+    (add-pango-fonts n 'sans sans factor)
+    (add-pango-fonts n 'typewriter typewriter factor)
+    n))
+    
+(define-public (make-pango-font-tree roman-str sans-str typewrite-str factor)
+  (let ((n (make-font-tree-node 'font-encoding 'fetaMusic)))
+    (add-music-fonts n 'feta "emmentaler" "emmentaler" feta-design-size-mapping factor)
+    (add-pango-fonts n 'roman roman-str factor)
+    (add-pango-fonts n 'sans sans-str factor)
+    (add-pango-fonts n 'typewriter typewrite-str factor)
+    n))
+
+(define-public (make-century-schoolbook-tree factor)
+  (make-pango-font-tree
+   "Century Schoolbook L"
+   "sans-serif"
+   "monospace"
+   factor))
+
+(define-public all-text-font-encodings
+  '(latin1))
+
+(define-public all-music-font-encodings
+  '(fetaBraces
+    fetaMusic
+    fetaText))
+
+(define-public (magstep s)
+  (exp (* (/ s 6) (log 2))))
+
+(define-public (magnification->font-size m)
+  (* 6 (/ (log m) (log 2))))

data/lib/lyp/etc/lyp.ly

@@ -0,0 +1,103 @@
+#(begin
+  (define lyp:path-separator "/")
+  ;(define lyp:path-separator (list->string (list
+  ;  (if (eq? PLATFORM 'windows) #\\ #\/ ))))
+  
+  (define (lyp:file-join . ls) (string-join ls lyp:path-separator))
+
+  ; hash table mapping package refs to package names
+  (define lyp:package-refs (make-hash-table))
+  
+  ; hash table mapping package names to package directories
+  (define lyp:package-dirs (make-hash-table))
+  
+  ; hash table mapping package names to loaded state
+  (define lyp:package-loaded? (make-hash-table))
+  
+  ; hash table mapping file paths to included state
+  (define lyp:file-included? (make-hash-table))
+
+  ; convert package ref to package name
+  (define (lyp:ref->name ref) (let* (
+      (clean-ref (car (string-split ref #\:)))
+      (name (hash-ref lyp:package-refs clean-ref))
+    )
+    (or name (throw 'lyp:failure "lyp:ref->name"
+      (format "Invalid package ref ~a" ref) #f))
+  ))
+  
+  ; convert package reef to directory
+  (define (lyp:name->dir name) (let (
+      (dir (hash-ref lyp:package-dirs name))
+    )
+    (or dir (throw 'lyp-failure "lyp:name->dir"
+      (format "Invalid package name ~a" ref) #f))
+  ))
+  
+  ; converts a package-relative path to absolute path. If the package is null,
+  ; uses lyp:current-package-dir (which value is valid only on package loading)
+  (define (lyp:package-file-path package path) (let* (
+      (base-path (if (null? package) 
+        lyp:current-package-dir (lyp:name->dir package)))
+    )
+    (lyp:file-join base-path path)
+  ))
+  
+  ; converts a package file reference to absolute path
+  (define (lyp:fileref->path ref) (let* (
+      (split (string-split ref #\:))
+      (qualified? (eq? (length split) 2))
+      (package (if qualified? (list-ref split 0) %nil))
+      (path (if qualified? (list-ref split 1) (list-ref split 0)))
+    )
+    (lyp:package-file-path package path)
+  ))
+  
+  (define (lyp:load ref) (load (lyp:fileref->path ref)))
+  
+  (define (lyp:include-ly-file path once-only?) (let* (
+      (included? (and once-only? (hash-ref lyp:file-included? path)))
+    )
+    (if (not (file-exists? path))
+      (throw 'lyp:failure "lyp:include-ly-file"
+        (format "File not found ~a" path) #f)
+    )
+    (if (not included?) (begin
+      (hash-set! lyp:file-included? path #t)
+      #{ \include #path #}
+    ))
+  ))
+  
+  (define (lyp:include ref)
+    (lyp:include-ly-file (lyp:fileref->path ref) #f))
+  (define (lyp:include-once ref)
+    (lyp:include-ly-file (lyp:fileref->path ref) #t))
+  
+  (define (lyp:require ref) (let* (
+      (name (lyp:ref->name ref))
+      (package-dir (lyp:name->dir name))
+      (entry-point-path (lyp:file-join package-dir "package.ly"))
+      (loaded? (hash-ref lyp:package-loaded? name))
+      (prev-package-dir lyp:current-package-dir)
+    )
+    (if (not loaded?) (begin
+      (ly:debug "Loading package ~a at ~a" name package-dir)
+      (set! lyp:current-package-dir package-dir)
+      (hash-set! lyp:package-loaded? name #t)
+      #{ \include #entry-point-path #}
+      (set! lyp:current-package-dir prev-package-dir)
+    ))
+  ))
+)
+
+% command form
+require = #(define-void-function (parser location ref)(string?)
+  (lyp:require ref))
+
+
+pinclude = #(define-void-function (parser location ref)(string?)
+  (lyp:include ref))
+
+pincludeOnce = #(define-void-function (parser location ref)(string?)
+  (lyp:include-once ref))
+

data/lib/lyp/git_based_rugged.rb

@@ -0,0 +1,44 @@
+# A quick-n-dirty rugged swap-in. Since the rugged gem includes a native 
+# extension (libgit2), and since traveling-ruby does not yet include an updated
+# version of it (the latest is 0.22.0b5 and we need >=0.23.0), we make a 
+# compromise, and make a traveling-ruby-based standalone release without 
+# rugged, but using plain git in order to install packages. So, users will have 
+# to have git installed on their machines.
+#
+# So here's an absolutely minimal replacement for rugged (just for the 
+# functionality we need) wrapping the git command.
+
+module Rugged
+  class Repository
+    def self.clone_at(url, path)
+      `git clone -q \"#{url}\" \"#{path}\"`
+      new(path)
+    end
+    
+    def initialize(path)
+      @path = path
+      exec('status')
+    end
+    
+    Ref  = Struct.new(:name)
+
+    def head
+      h = exec("show-ref --head").lines.map {|r| r =~ /^(\S+)\sHEAD$/ && $1}[0]
+      Ref.new(h)
+    end
+    
+     
+    def checkout(ref, opts)
+      # strategy: :force
+      exec("checkout -qf #{ref}")
+    end
+    
+    def tags
+      exec("tag").lines.map {|l| Ref.new(l.chomp)}
+    end 
+
+    def exec(cmd)
+      `cd #{@path} && git #{cmd}`
+    end
+  end
+end

data/lib/lyp/lilypond.rb

@@ -0,0 +1,570 @@
+require 'uri'
+require 'httpclient'
+require 'open3'
+require 'ruby-progressbar'
+
+module Lyp::Lilypond
+  class << self
+    def compile(argv, opts = {})
+      fn = Lyp.wrap(argv.pop, opts)
+      argv << fn
+      
+      invoke(argv, opts)
+    end
+    
+    def invoke(argv, opts = {})
+      lilypond = detect_use_version_argument(argv) || current_lilypond
+
+      case opts[:mode]
+      when :system
+        system("#{lilypond} #{argv.join(" ")}")
+      else
+        Kernel.exec(lilypond, *argv)
+      end
+    end
+    
+    def detect_use_version_argument(argv)
+      nil
+    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 
+    # 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 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
+        lilypond[:path]
+      else
+        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!
+      # check default
+      select_default_lilypond! unless valid_lilypond?(default_lilypond)
+      
+      set_current_lilypond(default_lilypond) unless valid_lilypond?(current_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
+        default = latest[:path]
+        set_default_lilypond(default)
+      else
+        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
+      "#{$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
+        if latest
+          default = latest[:path]
+          set_default_lilypond(default)
+        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")
+        list << {
+          root_path: root_path,
+          path: path,
+          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} -v`
+          if resp.lines.first =~ /LilyPond ([0-9\.]+)/i
+            m << {
+              root_path: File.expand_path(File.join(File.dirname(path), '..')),
+              path: path,
+              version: $1,
+              system: true
+            }
+          end
+        rescue
+          # ignore error
+        end
+        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}.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|        
+        versions << $1
+      end
+      
+      installed_versions = list.map {|l| l[:version]}
+      versions.select! {|v| version_match(v, version_specifier, versions)}
+      versions.map do |v|
+        {
+          version: v,
+          installed: installed_versions.include?(v)
+        }
+      end
+    end
+    
+    def version_match(version, specifier, all_versions)
+      case specifier
+      when 'latest'
+        version == all_versions.last
+      when 'stable'
+        Gem::Version.new(version).segments[1].even?
+      when 'unstable'
+        Gem::Version.new(version).segments[1].odd?
+      else
+        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)
+
+      lilypond_path = lyp_lilypond_path(version)
+      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/
+        version_specifier
+      when nil, 'stable'
+        latest_stable_version
+      when 'unstable'
+        latest_unstable_version
+      when 'latest'
+        latest_version
+      else
+        req = Gem::Requirement.new(version_specifier)
+        lilypond = search.reverse.find {|l| req =~ Gem::Version.new(l[:version])}
+        if lilypond
+          lilypond[:version]
+        else
+          raise "Could not find version matching #{version_specifier}"
+        end
+      end
+    end
+    
+    def detect_lilypond_platform
+      case RUBY_PLATFORM
+      when /x86_64-darwin/
+        "darwin-x86"
+      when /ppc-darwin/
+        "darwin-ppc"
+      when "i686-linux"
+        "linux-x86"
+      when "x86_64-linux"
+        "linux-64"
+      when "ppc-linux"
+        "linux-ppc"
+      when "x64-mingw32"
+        "mingw"
+      end
+    end
+  
+    def install_version(version, opts)
+      platform = detect_lilypond_platform
+      url = lilypond_install_url(platform, version, opts)
+      fn = temp_install_filename(url)
+
+      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
+
+    def lilypond_install_url(platform, version, opts)
+      ext = case platform
+      when /darwin/
+        ".tar.bz2"
+      when /linux/
+        ".sh"
+      when /mingw/
+        ".exe"
+      end
+      filename = "lilypond-#{version}-1.#{platform}"
+    
+      "#{BASE_URL}/#{platform}/#{filename}#{ext}"
+    end
+    
+    def temp_install_filename(url)
+      u = URI(url)
+      "#{$TMP_ROOT}/#{File.basename(u.path)}"
+    end
+  
+    def download_lilypond(url, fn, opts)
+      STDERR.puts "Downloading #{url}" unless opts[:silent]
+      
+      download_count = 0
+      client = HTTPClient.new
+      conn = client.get_async(url)
+      msg = conn.pop
+      total_size = msg.header['Content-Length'].first.to_i
+      io = msg.content
+
+      unless opts[:silent]
+        pbar = ProgressBar.create(title: 'Download', total: total_size)
+      end
+      File.open(fn, 'w+') do |f|
+        while data = io.read(10000)
+          download_count += data.bytesize
+          f << data
+          unless opts[:silent]
+            pbar.progress = download_count if download_count <= total_size
+          end
+        end
+      end
+      pbar.finish unless opts[:silent]
+    end
+  
+    def install_lilypond_files(fn, platform, version, opts)
+      tmp_target = "#{$TMP_ROOT}/lilypond-#{version}"
+      FileUtils.mkdir_p(tmp_target)
+
+      case platform
+      when /darwin/
+        install_lilypond_files_osx(fn, tmp_target, platform, version, opts)
+      when /linux/
+        install_lilypond_files_linux(fn, tmp_target, platform, version, opts)
+      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 
+    # 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]
+
+      # create temp directory in which to extract .sh file
+      tmp_dir = "#{$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")
+        sleep 0.5
+        raise "Windows installation failed" if Time.now - t1 >= 60
+      end
+
+      # Show lilypond versions
+      STDERR.puts `#{target_dir}/usr/bin/lilypond -v` unless opts[:silent] || opts[:no_version_test]
+    end
+
+    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
+
+    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] }
+        unless lilypond
+          raise "Could not find a system installed version of lilypond"
+        end
+      when 'latest'
+        lilypond = lilypond_list.first
+      when 'stable'
+        lilypond = lilypond_list.find do |v|
+          Gem::Version.new(v[:version]).segments[1].even?
+        end
+      when 'unstable'
+        lilypond = lilypond_list.find do |v|
+          Gem::Version.new(v[:version]).segments[1].odd?
+        end
+      else
+        version = "~>#{version}.0" if version =~ /^\d+\.\d+$/
+        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
+        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
+      
+      if list.empty?
+        if version_specifier
+          raise "No lilypond found matching #{version_specifier}"
+        else
+          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]
+        set_default_lilypond(nil) if l[:default]
+        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 = ""
+      success = nil
+      Open3.popen3(cmd) do |_in, _out, _err, wait_thr|
+        exit_value = wait_thr.value
+        $_out = _out.read
+        $_err = _err.read
+        success = exit_value == 0
+      end
+      if !success && raise_on_failure
+        raise "Error executing cmd #{cmd}: #{$_err}"
+      end
+      success
+    end
+  end
+end