lyp 1.3.8 → 1.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 42286097b2e4cd99e8aa37a56d619b9d956f186f
-  data.tar.gz: 0d707f212c1faadff367bdef5c0730af0992574b
+  metadata.gz: 99d6a748bd82c29990f8e0bda5139028d2e14718
+  data.tar.gz: ea3b89d3f3f4079b6583bf67b2a2888a0ed192b1
 SHA512:
-  metadata.gz: d96e71e9312822e75b6266a1585a889eb87d6b27cc4f7911db28c67129110d404a05e13c9e7289e928dbd861c1b11c80748376059e4cacedadd8f8627344bc6b
-  data.tar.gz: 0c1b22761be8007e4f5b2b2fb6e6307c88cc1f10c0e16a1ab0088eddc7b78dfdfcdbe3cf6e4f21ffbfd5e3bcc88ec4fdf5baa2130e92868623631afd482c0b4a
+  metadata.gz: 75e161b7d05a45e7caa4064e838a1e711743a7188e7681e34be43d328fe15af0a333d936e76372fdaa7a3f03b3715a383881dd41f94fc0e3cddae606b34146a1
+  data.tar.gz: cf2b052d9554a3a05534e54ca65d956dc28718dbe960ad7347dc406b4da6416ca411dfe867743c681ac6b3f626e1f60b8b9e81be750fee7536b7e2524f7dfcf9

data/README.md

@@ -2,20 +2,25 @@
   <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>
+  <a href="http://lyp.noteflakes.com/#/packages">The lyp package index</a>
 </p>
 
 # lyp - The Lilypond Swiss Army Knife
 
 lyp is an open-source tool that takes the pain out of working with [Lilypond](http://lilypond.org/).
 
-__Use packages__: Install [packages](http://lyp.noteflakes.com/#/?id=working-with-packages) to enhance your Lilypond files with additional functionality. Add [specialized tweaks](http://lyp.noteflakes.com/#/packages?id=tweaking) or even [change the music font](http://lyp.noteflakes.com/#/packages?id=fonts).
+__Use packages__: Install [packages](http://lyp.noteflakes.com/#/user-guide?id=working-with-packages) to enhance your Lilypond files with additional functionality. Add [specialized tweaks](http://lyp.noteflakes.com/#/packages?id=tweaking) or even [change the music font](http://lyp.noteflakes.com/#/packages?id=fonts).
 
-__No hassle Lilypond installation__: with lyp you can [install Lilypond](http://lyp.noteflakes.com/#/?id=installing-and-using-lilypond) with a single easy command, no need to click links, or unzip and copy files around.
+__No hassle Lilypond installation__: with lyp you can [install Lilypond](http://lyp.noteflakes.com/#/user-guide?id=installing-and-using-lilypond) with a single easy command, no need to click links, or unzip and copy files around.
 
-__Even more tools for power users__: watch and automatically [recompile](http://lyp.noteflakes.com/#/?id=lyp-watch) changed source files, [flatten](http://lyp.noteflakes.com/#/?id=lyp-flatten) include files, and [automatically install](http://lyp.noteflakes.com/#/?id=lyp-compile) package dependencies or any required version of Lilypond.
+__Even more tools for power users__: watch and automatically [recompile](http://lyp.noteflakes.com/#/user-guide?id=lyp-watch) changed source files, [flatten](http://lyp.noteflakes.com/#/user-guide?id=lyp-flatten) include files, and [automatically install](http://lyp.noteflakes.com/#/user-guide?id=lyp-compile) package dependencies or any required version of Lilypond.
 
-For more information, see the lyp [documentation](http://lyp.noteflakes.com/).
+## Documentation
+
+- [User guide](http://lyp.noteflakes.com/#/user-guide)
+- [Available packages](http://lyp.noteflakes.com/#/packages)
+- [Developer guide](http://lyp.noteflakes.com/#/developer-guide)
+- [FAQ](http://lyp.noteflakes.com/#/faq)
 
 ## Contributing
 

data/bin/install_release.sh

@@ -18,14 +18,14 @@ download() {
 
 echo "Detecting latest lyp version..."
 if has "curl"; then
-  LATEST_RELEASE=`curl -s https://github.com/noteflakes/lyp/releases/latest`
+  LATEST_RELEASE=`curl -Ls https://github.com/noteflakes/lyp/releases/latest`
 elif has "wget"; then
   LATEST_RELEASE=`wget -qO- https://github.com/noteflakes/lyp/releases/latest`
 else
   fail "Could not find curl or wget"
 fi
 
-VERSION_REGEX="tag/v([0-9\.]+)"
+VERSION_REGEX="Version ([0-9\.]+)"
 if [[ $LATEST_RELEASE =~ $VERSION_REGEX ]]
 then
   LYP_VERSION="${BASH_REMATCH[1]}"
@@ -34,7 +34,7 @@ else
 fi
 
 WORKDIR="/tmp/lyp-release-installer"
-URL_BASE="https://github.com/noteflakes/lyp/releases/download/v$LYP_VERSION"
+URL_BASE="https://github.com/noteflakes/lyp/releases/download/$LYP_VERSION"
 PLATFORM=`uname -sp`
 case $PLATFORM in
   "Linux x86_64")
@@ -62,4 +62,4 @@ tar -xzf "$WORKDIR/release.tar.gz" -C $WORKDIR
 
 $RELEASE_PATH/bin/lyp install self
 
-rm -rf $WORKDIR
+rm -rf $WORKDIR

data/bin/lilypond

@@ -37,6 +37,7 @@ Lyp-provided options:
   -R, --raw                           run raw lilypond (no pre-processing)
   -S, --snippet                       produce png cropped images at 600dpi
                                       (--cropped --png -dresolution=600)
+      --svg                           compile to SVG
   -u, --use=VERSION                   use the given version of lilypond
 EOF
 

data/bin/lyp-resolve

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path("../lib", File.dirname(__FILE__))
+
+require 'lyp'
+
+package = Lyp::DependencyResolver.find_package(ARGV[0])
+
+if package
+  STDOUT << package.path
+else
+  exit(1)
+end

data/lib/lyp/cli.rb

@@ -54,7 +54,7 @@ class Lyp::CLI < Thor
       "w" => :watch,
       "x" => :exec
 
-  check_unknown_options! :except => [:compile, :watch, :benchmark]
+  check_unknown_options! :except => [:compile, :exec, :watch, :benchmark]
   class_option :verbose, aliases: '-V', :type => :boolean, desc: 'show verbose output'
 
   no_commands do
@@ -129,9 +129,10 @@ class Lyp::CLI < Thor
   def compile(*argv)
     opts, argv = Lyp::Lilypond.preprocess_argv(argv)
     opts[:verbose] ||= options[:verbose]
+    argv.unshift('-V') if options[:verbose]
     $cmd_options = opts
 
-    lilypond_path = Lyp::Lilypond.select_lilypond_version(opts, argv.last)
+    Lyp::Lilypond.select_lilypond_version(opts, argv.last)
 
     $stderr.puts "Lyp #{Lyp::VERSION}" unless opts[:mode] == :quiet
     Lyp::System.test_installed_status!
@@ -156,7 +157,15 @@ class Lyp::CLI < Thor
 
   desc "exec <CMD> [<options>...]", "Execute a lilypond script"
   def exec(*argv)
-    $stderr.puts "Lyp #{Lyp::VERSION}"
+    opts, argv = Lyp::Lilypond.preprocess_bin_script_argv(argv)
+    opts[:verbose] ||= options[:verbose]
+    $cmd_options = opts
+
+    $cmd_options = opts
+
+    Lyp::Lilypond.select_lilypond_version(opts, argv.last)
+
+    $stderr.puts "Lyp #{Lyp::VERSION}" unless opts[:mode] == :quiet
     Lyp::System.test_installed_status!
     Lyp::Lilypond.invoke_script(argv, {})
   end

data/lib/lyp/etc/lyp.ly

@@ -4,15 +4,25 @@
 
   (use-modules
     (lily)
-    (ice-9 regex))
+    (ice-9 regex)
+    (ice-9 ftw))
+
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  ;;                  General utilities                     ;;
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+  (define (lyp:coerce-string x)
+    (if (symbol? x) (symbol->string x) x))
+
+  (define (lyp:list-string-or-symbol? x)
+    (or (list? x) (string? x) (symbol? x)))
 
   (define lyp:path-separator "/")
   (define (lyp:join-path . ls) (string-join ls lyp:path-separator))
 
   ; convert back-slashes to forward slashes (for use in lyp:split-path)
   (define (lyp:normalize-path path)
-    (regexp-substitute/global #f "[\\]+" path 'pre "/" 'post)
-  )
+    (regexp-substitute/global #f "[\\]+" path 'pre "/" 'post))
 
   (define (lyp:split-path path)
     (string-split (lyp:normalize-path path) #\/))
@@ -24,15 +34,14 @@
     (string-match lyp:absolute-path-pattern path))
 
   ; return an absolute path, resolving any . or .. parts
-  (define (lyp:expand-path path) (let* (
+  (define (lyp:expand-path path)
+    (let* (
       ; create a path list by joining the current directory
       (tmp-path (if (lyp:absolute-path? path)
                     path (lyp:join-path (ly-getcwd) path)))
       (src-list (lyp:split-path tmp-path))
       (dst-list '())
-    )
-    (for-each
-      (lambda (p)
+      (resolve (lambda (p)
         (cond
           ((eq? (length dst-list) 0) ; start of path
             (set! dst-list (list p)))
@@ -41,12 +50,54 @@
           ((string=? p "..") ; go up a level (remove last part from list)
             (set! dst-list (reverse (cdr (reverse dst-list)))))
           (else
-            (set! dst-list (append dst-list (list p))))))
-      src-list)
-    (apply lyp:join-path dst-list)
-  ))
+            (set! dst-list (append dst-list (list p)))))))
+    )
+    (for-each resolve src-list)
+    (apply lyp:join-path dst-list)))
+
+  (define (lyp:for-each-matching-file pat proc)
+    (let* (
+        (startdir (lyp:find-pattern-start-dir pat))
+        (pat-regexp (lyp:pattern->regexp pat))
+        (proc (lambda (fn st flag)
+          (begin
+            (if (and (eq? flag 'regular) (string-match pat-regexp fn))
+              (proc fn))
+            #t
+          )))
+      )
+      (ftw startdir proc)))
+
+  ; convert a filename wildcard pattern to a regexp
+  (define (lyp:pattern->regexp pat)
+    (let* (
+        (sub regexp-substitute/global)
+        (pat (sub #f "\\." pat 'pre "\\." 'post))
+        (pat (sub #f "\\*\\*/" pat 'pre "([^/]+/)@" 'post))
+        (pat (sub #f "\\*" pat 'pre "[^/]+" 'post))
+        (pat (sub #f "@" pat 'pre "*" 'post))
+      )
+      pat))
+
+  ; find the start directory for a given filename pattern
+  ; e.g. "abc/def/**/*.ly"  => "abc/def"
+  ;      "/repo/docs/*"     => "/repo/docs"
+  ;      "*.ly"             => "."
+  ;      "../src/*.ly"      => "../src"
+  ; if no start directory is found for the given pattern, returns "."
+  (define (lyp:find-pattern-start-dir pat)
+    (let* (
+        (match (string-match "^(([^\\*]+)(/))" pat))
+      )
+      (if match (match:substring match 2) ".")))
+
+  (define (lyp:directory? fn)
+    (and (file-exists? fn)
+         (eq? (stat:type (stat fn)) 'directory)))
 
-  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  ;;        package and include handling utilities          ;;
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
   ; hash table mapping package refs to package names
   (define lyp:package-refs (make-hash-table))
@@ -85,27 +136,20 @@
   (define (lyp:this-file) (or lyp:last-this-file lyp:input-filename))
   (define (lyp:this-dir) (dirname (lyp:this-file)))
 
-  (define (lyp:load path) (let* (
-      (current-file (lyp:this-file))
-      (current-dir  (dirname current-file))
-      (abs-path     (if (lyp:absolute-path? path)
-                        path
-                        (lyp:expand-path (lyp:join-path current-dir path))))
-    )
-    (if (not (file-exists? abs-path))
-      (throw 'lyp:failure "lyp:load"
-        (format "File not found ~a" abs-path) #f)
-    )
-    (ly:debug (format "lyp:load ~a\n" abs-path))
-    (set! lyp:last-this-file abs-path)
-    (load abs-path)
-    (set! lyp:last-this-file current-file)
-  ))
+  ; point to the entry point for the package being loaded
+  (define lyp:this-package-entry-point #f)
 
+  ; format include command for included file
+  ; the template also sets the lyp:last-this-file to the
+  ; included file, in order to keep track of file location
   (define (lyp:fmt-include path)
     (format "#(set! lyp:last-this-file \"~A\")\n\\include \"~A\"\n#(set! lyp:last-this-file \"~A\")\n"
       path path (lyp:this-file)))
 
+  ; format include command for a package
+  ; this template also sets the lyp:current-package-dir to the
+  ; package entry point path, and resets it to its previous
+  ; value after including the package files
   (define (lyp:fmt-require entry-point-path package-dir)
     (format "#(set! lyp:current-package-dir \"~A\")\n~A#(set! lyp:current-package-dir \"~A\")\n"
       package-dir (lyp:fmt-include entry-point-path) lyp:current-package-dir))
@@ -116,60 +160,193 @@
       (ly:parser-include-string str)
       (ly:parser-include-string parser str)))
 
-  (define (lyp:include parser location path once)  (let* (
-      (path (if (symbol? path) (symbol->string path) path))
-      (current-dir  (lyp:this-dir))
+  ; convert a path to an absolute path using the
+  ; directory for the currently processed file
+  (define (lyp:absolute-path-from-this-dir fn)
+  (if (lyp:absolute-path? fn)
+    fn
+    (lyp:expand-path (lyp:join-path (lyp:this-dir) fn))))
+
+  ; define list of finalizer lambdas to be called after the user's file has been
+  ; processed. packages invoke (lyp:finalize proc) to add their own code.
+  ; Finalizers are called in the order they were added.
+  (define lyp:final-procs '())
+
+  ; called after processing user's file, this procedure calls all registered
+  ; finalizers.
+  (define (lyp:call-finalizers)
+    (for-each (lambda (p) (p)) lyp:final-procs))
+
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  ;;                      lyp API                           ;;
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+  (define (lyp:load:ref ref once)
+    (let* (
+        (ref (lyp:coerce-string ref))
+      )
+      (cond
+        ((string-match "\\*" ref) (lyp:load:pattern pat once))
+        ((lyp:directory? ref) (lyp:load:pattern (string-append ref "/*")  once))
+        (else (lyp:load:file ref once)))
+  ))
+
+  (define (lyp:load:pattern pat once)
+    (lyp:for-each-matching-file pat (lambda (fn) (lyp:load:file fn once))))
+
+  (define (lyp:load:file fn once)
+    (let* (
+        (abs-fn (lyp:absolute-path-from-this-dir fn))
+        (abs-fn-ly (string-append abs-fn ".ly"))
+        (abs-fn-ily (string-append abs-fn ".ily"))
+      )
+      (cond
+        ((file-exists? abs-fn) (lyp:load:include abs-fn once))
+        ((and (file-exists? abs-fn-ly) (file-exists? abs-fn-ily)) 
+          (throw 'lyp-failure "lyp:load:file"
+            (format "Ambiguous filename ~a" fn) #f))
+        ((file-exists? abs-fn-ly) (lyp:load:include abs-fn-ly once))
+        ((file-exists? abs-fn-ily) (lyp:load:include abs-fn-ily once))
+        (else (throw 'lyp-failure "lyp:load:file"
+            (format "File not found: ~a" fn) #f)))))
+  
+  ; performs the include
+  ; this procedure expects the path to be absolute
+  ; and the file to exist
+  (define (lyp:load:include path once)
+    (if (not (and once (hash-ref lyp:file-included? path)))
+      (begin
+        (ly:debug "include ~a\n" path)
+        (hash-set! lyp:file-included? path #t)
+        (lyp:include-string (lyp:fmt-include path)))
+      #f))
+
+  ; load scheme file with correct relative path handling
+  ; (deprecated?)
+  (define (lyp:load path) (let* (
+      (current-file (lyp:this-file))
+      (current-dir  (dirname current-file))
       (abs-path     (if (lyp:absolute-path? path)
                         path
                         (lyp:expand-path (lyp:join-path current-dir path))))
-      (included?    (and once (hash-ref lyp:file-included? abs-path)))
     )
-
-    (if (not included?) (begin
-      (ly:debug "include ~a\n" abs-path)
-      (if (not (file-exists? abs-path))
-        (throw 'lyp:failure "lyp:include"
-          (format "File not found ~a" abs-path) #f))
-
-      (hash-set! lyp:file-included? abs-path #t)
-      (lyp:include-string (lyp:fmt-include abs-path))
-    ))
+    (if (not (file-exists? abs-path))
+      (throw 'lyp:failure "lyp:load"
+        (format "File not found ~a" abs-path) #f)
+    )
+    (ly:debug (format "lyp:load ~a\n" abs-path))
+    (set! lyp:last-this-file abs-path)
+    (load abs-path)
+    (set! lyp:last-this-file current-file)
   ))
 
-  ; define list of finalizer lambdas to be called after the user's file has been
-  ; processed. packages invoke (lyp:finalize proc) to add their own code.
-  ; Finalizers are called in the order they were added.
-  (define lyp:final-procs '())
+  ; add a finalizer to be called after user's file is processed
   (define (lyp:finalize proc)
     (set! lyp:final-procs (append lyp:final-procs (list proc))))
-  (define (lyp:call-finalizers)
-    (for-each (lambda (p) (p)) lyp:final-procs))
+
+  (define (lyp:require ref)
+    (let* (
+        (ref (lyp:coerce-string ref))
+        (name (lyp:ref->name ref))
+        (package-dir (lyp:name->dir name))
+        (entry-point-path (lyp:join-path package-dir "package.ly"))
+        (loaded? (hash-ref lyp:package-loaded? name))
+        (last-package-entry-point lyp:this-package-entry-point)
+      )
+      (if (not loaded?) (begin
+        (ly:debug "Loading package ~a at ~a" name package-dir)
+        (hash-set! lyp:package-loaded? name #t)
+        (set! lyp:this-package-entry-point entry-point-path)
+        (lyp:include-string (lyp:fmt-require entry-point-path package-dir))
+        (set! lyp:this-package-entry-point last-package-entry-point)))))
+
 )
 
-% command form
-require = #(define-void-function (parser location ref)(string-or-symbol?) (let* (
-    (ref (if (symbol? ref) (symbol->string ref) ref))
-    (name (lyp:ref->name ref))
-    (package-dir (lyp:name->dir name))
-    (entry-point-path (lyp:join-path package-dir "package.ly"))
-    (loaded? (hash-ref lyp:package-loaded? name))
-  )
-  (if (not loaded?) (begin
-    (ly:debug "Loading package ~a at ~a" name package-dir)
-    (hash-set! lyp:package-loaded? name #t)
-
-    (lyp:include-string (lyp:fmt-require entry-point-path package-dir))
-  ))
-))
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%                  Lilypond commands                     %%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
-pinclude = #(define-void-function (parser location path)(string-or-symbol?)
-  (lyp:include parser location path #f))
+lyp-load = #(define-void-function (parser location ref)(lyp:list-string-or-symbol?)
+  (if (list? ref)
+    (for-each (lambda (r) (lyp:load:ref r #f)) ref)
+    (lyp:load:ref ref #f)))
 
-pcondInclude = #(define-void-function (parser location expr path)(scheme? string-or-symbol?)
-  (if expr (lyp:include parser location path #f)))
+lyp-include = #(define-void-function (parser location ref)(lyp:list-string-or-symbol?)
+  (if (list? ref)
+    (for-each (lambda (r) (lyp:load:ref r #t)) ref)
+    (lyp:load:ref ref #t)))
+
+lyp-require = #(define-void-function (parser location ref)(lyp:list-string-or-symbol?)
+  (if (list? ref)
+    (for-each (lambda (r) (lyp:require r) ref))
+    (lyp:require ref)))
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%             Deprecated Lilypond commands               %%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+#(begin
+  (define (lyp:show-deprecated-msg location msg)
+    (if (not lyp:this-package-entry-point)
+      (begin
+        (if lyp:verbose 
+          (ly:input-warning location msg)
+          (ly:debug msg)
+        )
+        ; (ly:input-message location msg)
+        ;(lyp:show-deprecated-docs-msg)
+      )))
+  
+  (define lyp:deprecated-docs-msg-shown #f)
+
+  (define (lyp:show-deprecated--docs-msg)
+    (if (not lyp:deprecated-docs-msg-shown)
+    (begin
+      (set! lyp:deprecated-docs-msg-shown #t)
+      (lyp:finalize (lambda ()
+        (ly:debug lyp:msg:deprecated:docs))))))
+
+  (define lyp:msg:deprecated:pinclude
+    "\\pinclude is deprecated. Please use \\lyp-load instead.")
+
+  (define lyp:msg:deprecated:pincludeOnce
+    "\\pincludeOnce is deprecated. Please use \\lyp-include instead.")
+  
+  (define lyp:msg:deprecated:pcondInclude
+    "\\pcondInclude is deprecated. Please wrap your \\lyp-load call with a scheme expression.")
+  
+  (define lyp:msg:deprecated:pcondIncludeOnce
+    "\\pcondIncludeOnce is deprecated. Please wrap your \\lyp-include call with a scheme expression.")
+  
+  (define lyp:msg:deprecated:require
+    "\\require is deprecated. Please use \\lyp-require instead.")
+
+  (define lyp:msg:deprecated:docs
+    "\n****************************************\nThe code in your file and/or packages you use include deprecated commands that will be removed in a future version of lyp. For more information on deprecated commands see the lyp user guide:\n  http://lyp.noteflakes.com/\n****************************************\n")
+)
+
+pinclude = #(define-void-function (parser location ref)(string-or-symbol?)
+  (begin
+    (lyp:show-deprecated-msg location lyp:msg:deprecated:pinclude)
+    (lyp:load:ref ref #f)))
 
 pincludeOnce = #(define-void-function (parser location path)(string-or-symbol?)
-  (lyp:include parser location path #t))
+  (begin
+    (lyp:show-deprecated-msg location lyp:msg:deprecated:pincludeOnce)
+    (lyp:load:ref path #t)))
+
+pcondInclude = #(define-void-function (parser location expr path)(scheme? string-or-symbol?)
+  (begin
+    (lyp:show-deprecated-msg location lyp:msg:deprecated:pcondInclude)
+    (if expr (lyp:load:ref path #f))
+  ))
 
 pcondIncludeOnce = #(define-void-function (parser location expr path)(scheme? string-or-symbol?) 
-  (if expr (lyp:include parser location path #t)))
+  (begin
+    (lyp:show-deprecated-msg location lyp:msg:deprecated:pcondIncludeOnce)
+    (if expr (lyp:load:ref path #t))))
+
+require = #(define-void-function (parser location ref)(string-or-symbol?)
+  (begin
+    (lyp:show-deprecated-msg location lyp:msg:deprecated:require)
+    (lyp:require ref)))

data/lib/lyp/etc/support.scm

@@ -0,0 +1,54 @@
+;
+(use-modules
+  (ice-9 popen)
+  (ice-9 rdelim))
+
+(define (lyp:pread cmd)
+  (let* (
+      (port (open-input-pipe cmd))
+      (output (read-delimited "" port))
+    )
+    (close-pipe port)
+    (if (string? output)
+      output
+      (throw 'lyp:failure "lyp:pread"
+        (format "Command failed: ~a" cmd) #f))))
+
+; a hash mapping package refs to entry points
+(define lyp:package-entry-points (make-hash-table))
+
+; resolve a package reference
+;
+; The reference is first looked up in the package ref hash table.
+; if not found, the resolver is invoked, and the information
+; returned 
+(define (lyp:package-entry-point ref)
+  (catch #t
+    (lambda ()
+      (or 
+        (hash-ref lyp:package-entry-points ref)
+        (lyp:find-package ref)))
+    (lambda (key . parameters)
+      ; (set! error-thrown #t)
+      (throw 'lyp:failure "lyp:package-entry-point"
+        (format "Failed to resolve dependency ~a" ref) #f)
+      ))
+)
+
+(define (lyp:find-package ref)
+  (let* (
+      (cmd (string-append "bin/lyp-resolve " ref))
+      (path (lyp:pread cmd))
+    )
+    (hash-set! lyp:package-entry-points ref path)
+    path
+  )
+)
+
+(define (lyp:load-package ref)
+  (let* (
+      (path (lyp:package-entry-point ref))
+    )
+    (lyp:load:ref path #t)
+  )
+)

data/lib/lyp/lilypond.rb

@@ -66,6 +66,8 @@ module Lyp::Lilypond
       when '-S', '--snippet'
         argv_clean.concat ['-dbackend=eps', '-daux-files=#f', '--png', '-dresolution=600']
         options[:snippet_paper_preamble] = true
+      when '--svg'
+        argv_clean.concat ['-dbackend=svg']
       when '-u', '--use'
         options[:use_version] = argv.shift
       when '-V', '--verbose'
@@ -75,13 +77,50 @@ module Lyp::Lilypond
         options[:mode] = :system
       when '--invoke-quiet'
         options[:mode] = :quiet
-      when '--svg'
-        argv_clean.concat ['-dbackend=svg']
       else
         argv_clean << arg
       end
     end
 
+    def preprocess_bin_script_argv(argv)
+      options = {}
+      argv = argv.dup # copy for iterating
+      argv_clean = []
+      while arg = argv.shift
+        parse_lilypond_bin_script_arg(arg, argv, argv_clean, options)
+      end
+
+      [options, argv_clean]
+    end
+
+    def parse_lilypond_bin_script_arg(arg, argv, argv_clean, options)
+      case arg
+      when ARGUMENT_EQUAL_REGEXP
+        argv.insert(0, "--#{$1}", $2)
+      when ARGUMENT_SHORTHAND_REGEXP
+        argv.insert(0, "-#{$1}", $2)
+      when NO_ARGUMENT_SHORTHAND_REGEXP
+        tmp_args = []
+        $1.each_char {|c| tmp_args << "-#{c}"}
+        tmp_args << "-#{$2}"
+        argv.insert(0, *tmp_args)
+      when '-E', '--env'
+        unless ENV['LILYPOND_VERSION']
+          raise "$LILYPOND_VERSION not set"
+        end
+        options[:use_version] = ENV['LILYPOND_VERSION']
+      when '-n', '--install'
+        options[:install] = true
+      when '-u', '--use'
+        options[:use_version] = argv.shift
+      when '--invoke-system'
+        options[:mode] = :system
+      else
+        argv_clean << arg
+        argv_clean += argv
+      end
+    end
+
     def prepare_inline_music_file(music, opts = {})
       filename = Lyp.tmp_filename('.ly')
       File.open(filename, 'w+') do |f|
@@ -149,6 +188,10 @@ module Lyp::Lilypond
     def invoke(argv, opts = {})
       lilypond = current_lilypond
 
+      if opts[:verbose]
+        puts "#{lilypond} #{argv.join(" ")}"
+      end
+
       case opts[:mode]
       when :system
         system("#{lilypond} #{argv.join(" ")}")

data/lib/lyp/resolver.rb

@@ -120,7 +120,11 @@ module Lyp
       end
     end
 
-    DEP_RE = /\\(require|include|pinclude|pincludeOnce)\s+(?:"|#')?([^\s"]+)"?/.freeze
+    # DEP_RE = /\\((?:lyp[\-\:]require)|lyp-load|lyp-include|require|include|pinclude|pincludeOnce)\s+(?:"|#')?([^\s"\)]+)"?/.freeze
+    DEP_RE = /\\(lyp-require|lyp-load|lyp-include|require|include|pinclude|pincludeOnce)\s+(?:"|#')?([^\s"]+)"?/.freeze
+    LYP_REQUIRE = "lyp-require".freeze
+    LYP_INCLUDE = "lyp-include".freeze
+    LYP_LOAD    = "lyp-load".freeze
     INCLUDE = "include".freeze
     PINCLUDE = "pinclude".freeze
     PINCLUDE_ONCE = "pincludeOnce".freeze
@@ -183,9 +187,9 @@ module Lyp
         location[:line] += 1
         line.scan(DEP_RE) do |type, ref|
           case type
-          when INCLUDE, PINCLUDE, PINCLUDE_ONCE
+          when LYP_INCLUDE, LYP_LOAD, INCLUDE, PINCLUDE, PINCLUDE_ONCE
             process_include_command(ref, dir, leaf, opts, location)
-          when REQUIRE
+          when LYP_REQUIRE, REQUIRE
             process_require_command(ref, dir, leaf, opts, location)
           end
         end

data/lib/lyp/templates/deps_wrapper.rb

@@ -4,6 +4,9 @@
 #   package_paths: {
 #     <specifier> => <package path>
 #     ...
+#   },
+#   opts: {
+#     ...
 #   }
 # }
 
@@ -54,6 +57,7 @@ end
   (define lyp:input-filename {{quote_path[user_filename]}})
   (define lyp:input-dirname {{quote_path[user_dirname]}})
   (define lyp:current-package-dir {{quote_path[current_package_dir]}})
+  (define lyp:verbose {{_[:opts][:verbose] ? '#t' : '#f'}})
 `
 
 _[:package_refs].each do |spec, name|

data/lib/lyp/version.rb

@@ -1,3 +1,3 @@
 module Lyp
-  VERSION = "1.3.8"
+  VERSION = "1.3.9"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lyp
 version: !ruby/object:Gem::Version
-  version: 1.3.8
+  version: 1.3.9
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-05 00:00:00.000000000 Z
+date: 2018-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient
@@ -111,12 +111,14 @@ files:
 - bin/install_release.sh
 - bin/lilypond
 - bin/lyp
+- bin/lyp-resolve
 - lib/lyp.rb
 - lib/lyp/base.rb
 - lib/lyp/cli.rb
 - lib/lyp/etc/detect_system_lilypond.ly
 - lib/lyp/etc/font.scm
 - lib/lyp/etc/lyp.ly
+- lib/lyp/etc/support.scm
 - lib/lyp/git_based_rugged.rb
 - lib/lyp/lilypond.rb
 - lib/lyp/package.rb