lyp 1.0.0 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 54f90b19cc9702e07d9ea91f39cbb731b4160eca
-  data.tar.gz: ad54101546c7cfe1dbb9e5557d37a0cf39406b1c
+  metadata.gz: 6ee97de7db10409599600eb1e33133ca5e81171d
+  data.tar.gz: 97da159cbed5589c1c5049581dabf8c829f8301c
 SHA512:
-  metadata.gz: 579e5add9981c4fd1ad281e030e3b5fdffd2a3f51f4d0f81886ea1ab95a49bd92550619fa31a73f6d4987c4c3cf2d5e1ea7b2952363b6ca20440b5db977819c2
-  data.tar.gz: b3dd8a3af50d2120d5803fe33faacb90f9f7703fa38864d3cbc2ab0a296c0c141a3cd95bb7e3f8ccd288cd39a1284575f1a3472a40a5bce640bf6658078f419f
+  metadata.gz: 254a3af78bd69aa9783773060ca4c1554800a8433520ed60a75441a7c63bbfd9661c3c30cefe53f2d8bc520489a3db54edf59c9b32327eb7b098a06139fc8415
+  data.tar.gz: 62c0296ad688312460f8a097c3feff5abb827aafa00fef673501b7cb71b4c73ebae01aa55213e7f3a43129800716521b6c2ee27fdfc865386ae00c0022fc72f8

data/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <a href="https://travis-ci.org/noteflakes/lyp"><img src="https://travis-ci.org/noteflakes/lyp.svg?branch=master"</a>
+  <a href="https://travis-ci.org/noteflakes/lyp"><img src="https://travis-ci.org/noteflakes/lyp.svg?branch=master"></a>
 </p>
 <p align="center">
   <a href="https://github.com/lyp-packages/index#readme">The lyp package index</a>
@@ -32,7 +32,9 @@ __No hassle Lilypond installation__: With lyp you can also install any version o
 - [Developing packages](#developing-packages)
   - [The package interface](#the-package-interface)
   - [Including files](#including-files)
+  - [Scheme interface](#scheme-interface)
   - [Including fonts](#including-fonts)
+  - [Extending lyp](#extending-lyp)
   - [Testing packages](#testing-packages)
   - [Publishing packages](#publishing-packages)
 - [Installing and Using Lilypond](#installing-and-using-lilypond)
@@ -129,7 +131,7 @@ For more information on running lilypond see the section on [Running lilypond](#
 
 A package is a library of lilypond code, containing one or more lilypond files, that provide commonly-used functionality for users. A package can be a library of scheme code to extend lilypond, as in openlilylib; or a stylesheet which contains music fonts and additional lilypond code to change the look of the music: font, spacing, line widths, sizes, etc.
 
-The difference between merely copying and including a lilypond file in your music, and using a lilypond package is that you can easily share your music file with anyone and let them compile your music without having to download and copy additional code. lyp takes care of installing and resolving any dependencies in your lilypond files, so that you can compile your lilypond files anywhere without schlepping around a bunch of include files. Also, because packages are versioned, repeatable compilation using external code becomes trivial. 
+The difference between merely copying and including a lilypond file in your music, and using a lilypond package is that you can easily share your music file with anyone and let them compile your music without having to download and copy additional code. lyp takes care of installing and resolving any dependencies in your lilypond files, so that you can compile your lilypond files anywhere without schlepping around a bunch of include files. Also, because packages are versioned, repeatable compilation using external code becomes trivial.
 
 ### What constitutes a package?
 
@@ -329,7 +331,7 @@ Lyp also defines a `lyp:load` scheme function for loading scheme files using rel
 #(if (not (defined? 'mypack:init))(lyp:load "scm/init.scm"))
 ```
 
-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.
+Loading scheme files that way is a better technique than adding directories to `%load-path`, because this way one avoids possible name clashes, which may lead to unexpected behavior.
 
 ### Conditional includes
 
@@ -340,11 +342,39 @@ Files can also be included conditionally by evaluating a scheme expression using
 \pcondInclude #(eq? edition 'urtext) "urtext_tweaks.ly"
 ```
 
+### Scheme interface
+
+Lyp provides to loaded packages a small API to facilitate handling relative paths and loading of lilypond include files and scheme files. The API is documented on the [lyp wiki](https://github.com/noteflakes/lyp/wiki/Package-Scheme-Interface).  
+
 ### Including fonts
 
 Lyp also supports automatic installation of fonts, based on work by [Abraham Lee](https://github.com/tisimst). When a package is installed, lyp will copy any font files residing in the `fonts` directory into the corresponding `otf` and `svg` directories of all installed versions of lilypond.
 
-**Note**: fonts will be only installed in versions of lilypond starting from than 2.18.2. Lyp automatically patches any version ower than 2.19.12 in order to support custom fonts. 
+**Note**: fonts will be only installed in versions of lilypond starting from than 2.18.2. Lyp automatically patches any version newer than 2.19.12 in order to support custom fonts.
+
+### Extending lyp
+
+A package can also be used to extend or override lyp's stock functionality or add more features and commands. Extensions are written in Ruby in a file named `ext.rb` placed in the package's main directory. An extension can be used to either perform a certain action when the package is installed, or be loaded each time lyp is invoked.
+
+When a package is installed, lyp executes the code in `ext.rb`. To make the extension run each time lyp is invoked, the extension should include the following line:
+
+```ruby
+Lyp.install_extension(__FILE__)
+```
+
+More commands can be added to lyp's command line interface by adding methods to the `Lyp::CLI` class using the [Thor](https://github.com/erikhuda/thor/wiki/Method-Options) API. For example:
+
+```ruby
+class Lyp::CLI
+  desc "count", "show package count"
+  def count
+    packages = Lyp::Package.list_lyp_index("")
+    puts "#{packages.size} packages installed"
+  end
+end
+```
+
+The implementation of the stock lyp commands can be be found in [`lib/lyp/cli.rb`](./lib/lyp/cli.rb).
 
 ### Testing Packages
 
@@ -403,7 +433,7 @@ $ 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
 ```
@@ -506,7 +536,7 @@ Once one or more versions of lilypond are installed, the lilypond command may be
   $ lilypond --use=stable ...
   $ lilypond --use=latest ...
   ```
-  
+
 - `--env`, `-E` - use a version set by the `$LILYPOND_VERSION` environment variable:
 
   ```bash
@@ -518,7 +548,7 @@ Once one or more versions of lilypond are installed, the lilypond command may be
   ```bash
   $ lilypond -u2.19.35 -n ...
   ```
-  
+
 - `--raw`, `-r` - do not pre-process input file (no scanning for dependencies, no wrapping).
 
   ```bash
@@ -535,4 +565,4 @@ $ bundle install # needs to be run only once
 $ rspec
 ```
 
-Please feel free to submit issues and pull requests.
+Please feel free to submit issues and pull requests.

data/bin/install_release.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-LYP_VERSION="1.0.0"
+LYP_VERSION="1.0.3"
 WORKDIR="/tmp/lyp-release-installer"
 URL_BASE="https://github.com/noteflakes/lyp/releases/download/v$LYP_VERSION"
 
@@ -8,8 +8,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

data/bin/lilypond

@@ -6,8 +6,7 @@ require 'lyp/version'
 require 'lyp'
 
 $options, $argv = Lyp::Lilypond.preprocess_argv(ARGV)
-
-$lilypond_path = Lyp::Lilypond.select_lilypond_version($options)
+$lilypond_path = Lyp::Lilypond.select_lilypond_version($options, ARGV.last)
 
 if $options[:raw]
   exec("#{$lilypond_path} #{$argv.join(' ')}")
@@ -27,6 +26,7 @@ Lyp-provided options:
   -A, --auto-install-deps             install any missing dependencies
   -c, --cropped                       crop output (requires setting 0 margins)
   -E, --env                           use version specified in $LILYPOND_VERSION
+  -F, --force_version                 use lilypond version specified in user file
   -n, --install                       install the specified version if not found
   -O, --open                          open the target file after compilation
   -R, --raw                           run raw lilypond (no pre-processing)

data/lib/lyp/base.rb

@@ -75,5 +75,12 @@ module Lyp
     response = Readline.readline(prompt)
     ["y", "yes"].include?(response)
   end
-end
 
+  def self.version(v)
+    Gem::Version.new(v)
+  end
+
+  def self.version_req(r)
+    Gem::Requirement.new(r)
+  end
+end

data/lib/lyp/cli.rb

@@ -103,7 +103,7 @@ class Lyp::CLI < Thor
   def compile(*argv)
     opts, argv = Lyp::Lilypond.preprocess_argv(argv)
 
-    lilypond_path = Lyp::Lilypond.select_lilypond_version(opts)
+    lilypond_path = Lyp::Lilypond.select_lilypond_version(opts, argv.last)
 
     $stderr.puts "Lyp #{Lyp::VERSION}"
     Lyp::System.test_installed_status!

data/lib/lyp/etc/lyp.ly

@@ -134,6 +134,18 @@
       (lyp:include-string (lyp:fmt-include abs-path))
     ))
   ))
+
+  ; define list of finalizer lambdas to be called after the user's file has been
+  ; \included.
+  (module-define! (current-module) 'lyp:finalProcs '())
+  (define (lyp:getFinalProcs)
+    (module-ref (current-module) 'lyp:finalProcs))
+  (define (lyp:setFinalProcs l) 
+    (module-define! (current-module) 'lyp:finalProcs l))
+  (define (lyp:finalize proc)
+    (lyp:setFinalProcs (append (lyp:getFinalProcs) (list proc))))
+  (define (lyp:callFinalizers)
+    (for-each (lambda (p) (p)) (lyp:getFinalProcs)))
 )
 
 % command form

data/lib/lyp/lilypond.rb

@@ -4,56 +4,78 @@ require 'ruby-progressbar'
 
 module Lyp::Lilypond
   class << self
+    NO_ARGUMENT_OPTIONS_REGEXP = /^\-([REnFOcSA]+)(.+)/
+
     def preprocess_argv(argv)
       options = {}
       argv = argv.dup # copy for iterating
       argv_clean = []
       while arg = argv.shift
-        case arg
-        when '-R', '--raw'
-          options[:raw] = true
-        when '-r', '--require'
-          options[:ext_require] ||= []
-          options[:ext_require] << argv.shift
-        when /^(?:\-r|\-\-require\=)"?([^\s]+)"?/
-          options[:ext_require] ||= []
-          options[:ext_require] << $1
-        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
-        when '-O', '--open'
-          options[:open] = true
-        when '-c', '--cropped'
-          argv_clean += ['-dbackend=eps', '-daux-files=#f']
-        when '-S', '--snippet'
-          argv_clean += ['-dbackend=eps', '-daux-files=#f', '--png', '-dresolution=600']
-        when '-A', '--auto-install-deps'
-          options[:resolve] = true
-        else
-          argv_clean << arg
-        end
+        parse_lilypond_arg(arg, argv, argv_clean, options)
       end
 
       [options, argv_clean]
     end
 
-    def select_lilypond_version(opts)
-      if opts[:use_version]
-        if opts[:install]
-          Lyp::Lilypond.install_if_missing(opts[:use_version])
+    def parse_lilypond_arg(arg, argv, argv_clean, options)
+      case arg
+      when NO_ARGUMENT_OPTIONS_REGEXP
+        # handle multiple options in shorthand form, e.g. -FnO
+        tmp_args = []
+        $1.each_char {|c| tmp_args << "-#{c}"}
+        tmp_args << "-#{$2}"
+        argv = tmp_args + argv
+      when '-A', '--auto-install-deps'
+        options[:resolve] = true
+      when '-c', '--cropped'
+        argv_clean += ['-dbackend=eps', '-daux-files=#f']
+      when '-E', '--env'
+        unless ENV['LILYPOND_VERSION']
+          STDERR.puts "$LILYPOND_VERSION not set"
+          exit 1
         end
-        Lyp::Lilypond.force_version!(opts[:use_version])
+        options[:use_version] = ENV['LILYPOND_VERSION']
+      when '-F', '--force-version'
+        options[:force_version] = true
+      when '-n', '--install'
+        options[:install] = true
+      when '-O', '--open'
+        options[:open] = true
+      when '-r', '--require'
+        options[:ext_require] ||= []
+        options[:ext_require] << argv.shift
+      when /^(?:\-r|\-\-require\=)"?([^\s]+)"?/
+        options[:ext_require] ||= []
+        options[:ext_require] << $1
+      when '-R', '--raw'
+        options[:raw] = true
+      when '-S', '--snippet'
+        argv_clean += ['-dbackend=eps', '-daux-files=#f', '--png', '-dresolution=600']
+        options[:snippet_paper_preamble] = true
+      when '-u', '--use'
+        options[:use_version] = argv.shift
+      when /^(?:\-u|\-\-use\=)"?([^\s]+)"?/
+        options[:use_version] = $1
+      else
+        argv_clean << arg
       end
+    end
+
+    VERSION_STATEMENT_REGEX = /\\version "([^"]+)"/
+
+    def select_lilypond_version(opts, file_path)
+      forced_version = opts[:force_version] ?
+        get_file_expected_version(file_path) : opts[:use_version]
+
+      if forced_version
+        Lyp::Lilypond.install_if_missing(forced_version) if opts[:install]
+        Lyp::Lilypond.force_version!(forced_version)
+      end
+
       Lyp::Lilypond.check_lilypond!
+
+      opts[:lilypond_version] = current_lilypond_version
+
       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'."
@@ -65,6 +87,16 @@ module Lyp::Lilypond
       exit 1
     end
 
+    def get_file_expected_version(file_path)
+      if IO.read(file_path) =~ VERSION_STATEMENT_REGEX
+        $1
+      else
+        raise "Could not find version statement in #{file_path}"
+      end
+    rescue => e
+      raise "Failed to read #{file_path}"
+    end
+
     def compile(argv, opts = {})
       unless argv.last == '-'
         fn = Lyp.wrap(argv.pop, opts)
@@ -80,6 +112,9 @@ module Lyp::Lilypond
       case opts[:mode]
       when :system
         system("#{lilypond} #{argv.join(" ")}")
+      when :spawn
+        pid = spawn(lilypond, *argv, opts[:spawn_opts] || {})
+        Process.detach(pid)
       else
         Kernel.exec(lilypond, *argv)
       end
@@ -112,7 +147,7 @@ module Lyp::Lilypond
       path = current_lilypond
       version = File.basename(File.expand_path("#{File.dirname(path)}/../.."))
 
-      unless (Gem::Version.new(version) rescue nil)
+      unless (Lyp.version(version) rescue nil)
         resp = `#{path} -v`
         if resp.lines.first =~ /LilyPond ([0-9\.]+)/i
           version = $1
@@ -149,6 +184,7 @@ module Lyp::Lilypond
 
     attr_reader :forced_version
 
+    # Make sure there's a default and current lilypond set
     def check_lilypond!
       path = default_lilypond
       select_default_lilypond! unless path && path =~ /lilypond$/
@@ -186,7 +222,7 @@ module Lyp::Lilypond
     end
 
     CMP_VERSION = proc do |x, y|
-      Gem::Version.new(x[:version]) <=> Gem::Version.new(y[:version])
+      Lyp.version(x[:version]) <=> Lyp.version(y[:version])
     end
 
     def filter_installed_list(version_specifier)
@@ -304,24 +340,24 @@ module Lyp::Lilypond
       when 'latest'
         version == all_versions.last
       when 'stable'
-        Gem::Version.new(version).segments[1].even?
+        Lyp.version(version).segments[1].even?
       when 'unstable'
-        Gem::Version.new(version).segments[1].odd?
+        Lyp.version(version).segments[1].odd?
       else
-        Gem::Requirement.new(specifier) =~ Gem::Version.new(version)
+        Lyp.version_req(specifier) =~ Lyp.version(version)
       end
     end
 
     def latest_stable_version
-      search.reverse.find {|l| Gem::Version.new(l[:version]).segments[1].even?}[:version]
+      search.reverse.find {|l| Lyp.version(l[:version]).segments[1].even?}[:version]
     end
 
     def latest_unstable_version
-      search.reverse.find {|l| Gem::Version.new(l[:version]).segments[1].odd?}[:version]
+      search.reverse.find {|l| Lyp.version(l[:version]).segments[1].odd?}[:version]
     end
 
     def latest_installed_unstable_version
-      latest = list.reverse.find {|l| Gem::Version.new(l[:version]).segments[1].odd?}
+      latest = list.reverse.find {|l| Lyp.version(l[:version]).segments[1].odd?}
       latest ? latest[:version] : nil
     end
 
@@ -362,8 +398,8 @@ module Lyp::Lilypond
       when 'latest'
         latest_version
       else
-        req = Gem::Requirement.new(version_specifier)
-        lilypond = search.reverse.find {|l| req =~ Gem::Version.new(l[:version])}
+        req = Lyp.version_req(version_specifier)
+        lilypond = search.reverse.find {|l| req =~ Lyp.version(l[:version])}
         if lilypond
           lilypond[:version]
         else
@@ -536,7 +572,7 @@ module Lyp::Lilypond
     end
 
     def patch_font_scm(version)
-      return unless Lyp::FONT_PATCH_REQ =~ Gem::Version.new(version)
+      return unless Lyp::FONT_PATCH_REQ =~ Lyp.version(version)
 
       target_fn = File.join(lyp_lilypond_share_dir(version), 'lilypond/current/scm/font.scm')
       FileUtils.cp(Lyp::FONT_PATCH_FILENAME, target_fn)
@@ -552,7 +588,7 @@ module Lyp::Lilypond
     EOF
 
     def patch_system_lilypond_font_scm(lilypond, opts)
-      return false unless Lyp::FONT_PATCH_REQ =~ Gem::Version.new(lilypond[:version])
+      return false unless Lyp::FONT_PATCH_REQ =~ Lyp.version(lilypond[:version])
 
       target_fn = File.join(lilypond[:data_path], '/scm/font.scm')
       # do nothing if alredy patched
@@ -574,7 +610,7 @@ module Lyp::Lilypond
     end
 
     def copy_fonts_from_all_packages(version, opts)
-      return unless Lyp::FONT_COPY_REQ =~ Gem::Version.new(version)
+      return unless Lyp::FONT_COPY_REQ =~ Lyp.version(version)
 
       ly_fonts_dir = File.join(lyp_lilypond_share_dir(version), 'lilypond/current/fonts')
 
@@ -612,16 +648,16 @@ module Lyp::Lilypond
         lilypond = lilypond_list.first
       when 'stable'
         lilypond = lilypond_list.find do |v|
-          Gem::Version.new(v[:version]).segments[1].even?
+          Lyp.version(v[:version]).segments[1].even?
         end
       when 'unstable'
         lilypond = lilypond_list.find do |v|
-          Gem::Version.new(v[:version]).segments[1].odd?
+          Lyp.version(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])}
+        req = Lyp.version_req(version)
+        lilypond = lilypond_list.find {|v| req =~ Lyp.version(v[:version])}
       end
 
       unless lilypond

data/lib/lyp/package.rb

@@ -13,14 +13,14 @@ module Lyp::Package
       if pattern
         if (pattern =~ /[@\>\<\=\~]/) && (pattern =~ Lyp::PACKAGE_RE)
           package, version = $1, $2
-          req = Gem::Requirement.new(version) rescue nil
+          req = Lyp.version_req(version) rescue nil
           packages.select! do |p|
             p =~ Lyp::PACKAGE_RE
             p_pack, p_ver = $1, $2
 
             next false unless p_pack == package
 
-            if req && (p_gemver = Gem::Version.new(p_ver) rescue nil)
+            if req && (p_gemver = Lyp.version(p_ver) rescue nil)
               req =~ p_gemver
             else
               p_ver == version
@@ -38,8 +38,8 @@ module Lyp::Package
         x =~ Lyp::PACKAGE_RE; x_package, x_version = $1, $2
         y =~ Lyp::PACKAGE_RE; y_package, y_version = $1, $2
 
-        x_version = (x_version && Gem::Version.new(x_version) rescue x)
-        y_version = (y_version && Gem::Version.new(y_version) rescue y)
+        x_version = (x_version && Lyp.version(x_version) rescue x)
+        y_version = (y_version && Lyp.version(y_version) rescue y)
 
         if (x_package == y_package) && (x_version.class == y_version.class)
           x_version <=> y_version
@@ -238,7 +238,11 @@ module Lyp::Package
       puts "Cloning #{url}..." unless opts[:silent]
       Rugged::Repository.clone_at(url, tmp_path)
     rescue => e
-      raise "Could not clone repository (please check that the package URL is correct.)"
+      if opts[:verbose]
+        raise e
+      else
+        raise "Could not clone repository (please check that the package URL is correct.)"
+      end
     end
 
     def checkout_package_version(repo, version, opts = {})
@@ -281,7 +285,7 @@ module Lyp::Package
       req = Lyp::FONT_COPY_REQ
 
       Lyp::Lilypond.list.each do |lilypond|
-        next unless req =~ Gem::Version.new(lilypond[:version])
+        next unless req =~ Lyp.version(lilypond[:version])
 
         if lilypond[:system]
           next unless Lyp.confirm_action(SYSTEM_LILYPOND_PROMPT % lilypond[:version])
@@ -409,9 +413,9 @@ module Lyp::Package
       when nil, '', 'latest'
         highest_versioned_tag(repo) || 'master'
       when /^(\>=|~\>|\d)/
-        req = Gem::Requirement.new(version_specifier)
+        req = Lyp.version_req(version_specifier)
         tag = repo_tags(repo).reverse.find do |t|
-          (v = tag_version(t.name)) && (req =~ Gem::Version.new(v))
+          (v = tag_version(t.name)) && (req =~ Lyp.version(v))
         end
         unless tag
           raise "Could not find a version matching #{version_specifier}"
@@ -424,7 +428,7 @@ module Lyp::Package
     end
 
     def highest_versioned_tag(repo)
-      tag = repo_tags(repo).select {|t| Gem::Version.new(tag_version(t.name)) rescue nil}.last
+      tag = repo_tags(repo).select {|t| Lyp.version(tag_version(t.name)) rescue nil}.last
       tag && tag.name
     end
 
@@ -436,7 +440,7 @@ module Lyp::Package
       tags.sort do |x, y|
         x_version, y_version = tag_version(x.name), tag_version(y.name)
         if x_version && y_version
-          Gem::Version.new(x_version) <=> Gem::Version.new(y_version)
+          Lyp.version(x_version) <=> Lyp.version(y_version)
         else
           x.name <=> y.name
         end

data/lib/lyp/resolver.rb

@@ -361,7 +361,7 @@ module Lyp
 
       map = lambda do |m, p|
         if p =~ Lyp::PACKAGE_RE
-          m[$1] = versions[p] ||= (Gem::Version.new($2 || '0.0') rescue nil)
+          m[$1] = versions[p] ||= (Lyp.version($2 || '0.0') rescue nil)
         end
         m
       end
@@ -426,10 +426,10 @@ module Lyp
         req_version = 'forced'
       end
 
-      req = Gem::Requirement.new(req_version || '>=0') rescue nil
+      req = Lyp.version_req(req_version || '>=0') rescue nil
       available_packages.select do |package, leaf|
         if (package =~ Lyp::PACKAGE_RE) && (req_package == $1)
-          version = Gem::Version.new($2 || '0') rescue nil
+          version = Lyp.version($2 || '0') rescue nil
           if version.nil? || req.nil?
             req_version.nil? || (req_version == $2)
           else
@@ -473,8 +473,8 @@ module Lyp
       specifiers = map_specifiers_to_versions
 
       compare_versions = lambda do |x, y|
-        v_x = x =~ Lyp::PACKAGE_RE && Gem::Version.new($2)
-        v_y = y =~ Lyp::PACKAGE_RE && Gem::Version.new($2)
+        v_x = x =~ Lyp::PACKAGE_RE && Lyp.version($2)
+        v_y = y =~ Lyp::PACKAGE_RE && Lyp.version($2)
         x <=> y
       end
 

data/lib/lyp/system.rb

@@ -2,7 +2,7 @@ require 'fileutils'
 
 module Lyp::System
   class << self
-    RUGGED_REQ = Gem::Requirement.new('>=0.23.0')
+    RUGGED_REQ = Lyp.version_req('>=0.23.0')
     
     def test_rugged_gem!
       return if @already_tested

data/lib/lyp/templates/deps_wrapper.rb

@@ -7,6 +7,12 @@
 #   }
 # }
 
+if _[:opts][:lilypond_version]
+`
+\version "{{_[:opts][:lilypond_version]}}"
+`
+end
+
 require 'fileutils'
 
 user_filename = File.expand_path(_[:user_file])
@@ -20,15 +26,27 @@ end
 current_package_dir = _[:current_package_dir] || FileUtils.pwd
 
 # The wrapper defines a few global variables:
-# 
+#
 # lyp:input-filename      - the absolute path to the input file name
 # lyp:input-dirname       - the absolute path to the input file directory name
 # lyp:current-package-dir - the directory for the package currently being loaded
-# lyp:package-refs        - a hash table mapping package refs to package entry 
+# lyp:package-refs        - a hash table mapping package refs to package entry
 #                           point absolute paths
 # lyp:package-loaded      - a hash table for keeping track of loaded packages
 # lyp:file-included       - a hash table for keeping track of include files
 
+if _[:opts][:snippet_paper_preamble]
+`
+\paper {
+  indent = 0\mm
+  oddHeaderMarkup = ""
+  evenHeaderMarkup = ""
+  oddFooterMarkup = ""
+  evenFooterMarkup = ""
+}
+`
+end
+
 `
 #(ly:set-option 'relative-includes #t)
 \include "{{Lyp::LYP_LY_LIB_PATH}}"
@@ -67,5 +85,5 @@ end
 `
 \include {{quote_path[user_filename]}}
 
-#(if (defined? 'assert:summary) (assert:summary))
+#(lyp:callFinalizers)
 `

data/lib/lyp/version.rb

@@ -1,3 +1,3 @@
 module Lyp
-  VERSION = "1.0.0"
+  VERSION = "1.0.3"
 end

data/lib/lyp/wrapper.rb

@@ -7,7 +7,6 @@ module Lyp
 
   def self.wrap(fn, opts = {})
     r = Lyp::DependencyResolver.new(fn, opts).resolve_package_dependencies
-
     # copy current_package_dir option
     r[:current_package_dir] = opts[:current_package_dir]
     r[:opts] = opts

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lyp
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.3
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-29 00:00:00.000000000 Z
+date: 2016-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient