lyp-win 0.3.5 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: afd48348c59bf85030e6ff6503c45d5a677a541b
-  data.tar.gz: 24379cc9ee854d468587469286a6c5e306e39f7e
+  metadata.gz: bcd584088a605705ca3dd2da68b7091971b4a54a
+  data.tar.gz: 9d979652b8d29b20200b554603cfe411a92592da
 SHA512:
-  metadata.gz: 3f2e34ffb30279e65d66e9b8ec18861a9f06fdf2d88b190a285901b451e064782ffdb70be1d1f455864266bfbe95e74a38cf7d0183f3c62268915e37375b30f2
-  data.tar.gz: 74f2e49025ce8b1049e348c28666fc7d0181fc0a603066fcc994d49b47298b3b357c65576f8c43a8ebea3542d5c1bf34b48a890179451dfbfb44eaab41bda642
+  metadata.gz: 3137343b1150ff6c1fbded1362aed582b78900e0720b63a31fc471908a0e3dfef2d1c12a4576a91beeeb299d1d2b4ee054da08ae8750d696523615e73eaa9d91
+  data.tar.gz: 07648102dac19de97b57fa77e902fd3b69c767f2fd018d40d5aac0357983210ac083988d1bbcd6783e3ce23710bebfe7d34b01ef5ef69af74ead678546bf07a8

data/bin/install_release.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-LYP_VERSION="0.3.5"
+LYP_VERSION="0.3.6"
 WORKDIR="/tmp/lyp-release-installer"
 URL_BASE="https://github.com/noteflakes/lyp/releases/download/v$LYP_VERSION"
 

data/bin/lilypond

@@ -5,54 +5,9 @@ $LOAD_PATH.unshift File.expand_path("../lib", File.dirname(__FILE__))
 require 'lyp/version'
 require 'lyp'
 
-def process_argv
-  options = {}
-  argv = ARGV.dup # copy for iterating
-  argv_clean = []
-  while arg = argv.shift
-    case arg
-    when '-r', '--raw'
-      options[:raw] = true
-    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
-    else
-      argv_clean << arg
-    end
-  end
-
-  [options, argv_clean]
-end
-$options, $argv = process_argv
+$options, $argv = Lyp::Lilypond.preprocess_argv(ARGV)
 
-def get_lilypond_path
-  if $options[:use_version]
-    if $options[:install]
-      Lyp::Lilypond.install_if_missing($options[:use_version])
-    end
-    Lyp::Lilypond.force_version!($options[:use_version])
-  end
-  Lyp::Lilypond.check_lilypond!
-  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'."
-      exit 1
-    end
-  end
-rescue => e
-  STDERR.puts e.message
-  exit 1
-end
-$lilypond_path = get_lilypond_path
+$lilypond_path = Lyp::Lilypond.select_lilypond_version($options)
 
 if $options[:raw]
   exec("#{$lilypond_path} #{$argv.join(' ')}")
@@ -68,10 +23,11 @@ LILYPOND_HELP_SWITCHES = %w{
 }
 LYP_LY_HELP = <<EOF
 Lyp-provided options:
-  -r, --raw                           run raw lilypond (no pre-processing)
   -E, --env                           use version specified in $LILYPOND_VERSION
+  -n, --install                       install the specified version if not found
+  -R, --raw                           run raw lilypond (no pre-processing)
+  -r, --require=PACKAGE               preload the specified package
   -u, --use=VERSION                   use the given version of lilypond
-  -n, --install                       install the given version if not found
 EOF
 
 case $argv.first

data/lib/lyp/cli.rb

@@ -45,7 +45,7 @@ class Lyp::CLI < Thor
   package_name "lyp"
   map "-v" => :version
   check_unknown_options! :except => :compile
-  class_option :verbose, aliases: '-V', :type => :boolean
+  class_option :verbose, aliases: '-V', :type => :boolean, desc: 'show verbose output'
   
   desc "version", "show Lyp version"
   def version
@@ -100,33 +100,14 @@ class Lyp::CLI < Thor
   end
 
   desc "compile [<option>...] <FILE>", "Invokes lilypond with given file"
-  method_option :install, aliases: '-n', type: :boolean, desc: 'Install the requested version of lilypond if not present'
-  method_option :env, aliases: '-E', type: :boolean, desc: 'Use version set by LILYPOND_VERSION environment variable'
-  method_option :use, aliases: '-u', type: :string, desc: 'Use specified version'
-  def compile(*args)
-    $cmd_options = options
+  def compile(*argv)
+    opts, argv = Lyp::Lilypond.preprocess_argv(argv)
 
-    if options[:env]
-      unless ENV['LILYPOND_VERSION']
-        STDERR.puts "$LILYPOND_VERSION not set"
-        exit 1
-      end
-      options[:use] = ENV['LILYPOND_VERSION']
-    end
-    
-    if options[:use]
-      if options[:install]
-        Lyp::Lilypond.install_if_missing(options[:use], no_version_test: true)
-      end
-      Lyp::Lilypond.force_version!(options[:use])
-    end
+    lilypond_path = Lyp::Lilypond.select_lilypond_version(opts)
 
-    # check lilypond default / current settings
-    Lyp::Lilypond.check_lilypond!
-    
     $stderr.puts "Lyp #{Lyp::VERSION}"
     Lyp::System.test_installed_status!
-    Lyp::Lilypond.compile(args)
+    Lyp::Lilypond.compile(argv, opts)
   end
   
   desc "test [<option>...] [.|PATTERN]", "Runs package tests on installed packages or local directory"

data/lib/lyp/etc/lyp.ly

@@ -96,62 +96,59 @@
       (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 (lyp:do-include parser path)
+  (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)))
+      
+  (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))
+  
+  ; helper function to cover API changes from 2.18 to 2.19
+  (define (lyp:include-string str)
     (if (defined? '*parser*)
-      (ly:parser-parse-string (ly:parser-clone)
-        (format "\\include \"~a\"" path))
-      (ly:parser-parse-string (ly:parser-clone parser)
-        (format "\\include \"~a\"" path))))
+      (ly:parser-include-string str)
+      (ly:parser-include-string parser str)))
 )
 
 % command form
 require = #(define-void-function (parser location ref)(string?) (let* (
-    (current-file (lyp:this-file))
     (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))
-    (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)
     
-    (set! lyp:last-this-file entry-point-path)
-    (lyp:do-include parser entry-point-path)
-    (set! lyp:last-this-file current-file)
-    
-    (set! lyp:current-package-dir prev-package-dir)
+    (lyp:include-string (lyp:fmt-require entry-point-path package-dir))
   ))
 ))
     
 pinclude = #(define-void-function (parser location path)(string?) (let* (
-    (current-file (lyp:this-file))
-    (current-dir  (dirname current-file))
+    (current-dir  (lyp:this-dir))
     (abs-path     (if (lyp:absolute-path? path)
                       path
                       (lyp:expand-path (lyp:join-path current-dir path))))
   )
-  (ly:debug (format "\\pinclude ~a\n" abs-path))
+  (ly:debug "\\pinclude ~a\n" abs-path)
   (if (not (file-exists? abs-path))
     (throw 'lyp:failure "\\pinclude"
       (format "File not found ~a" abs-path) #f))
 
   (hash-set! lyp:file-included? abs-path #t)
-  (set! lyp:last-this-file abs-path)
-  (lyp:do-include parser abs-path)
-  (set! lyp:last-this-file current-file)
+  (lyp:include-string (lyp:fmt-include abs-path))
 ))
 
 pincludeOnce = #(define-void-function (parser location path)(string?) (let* (
-    (current-file (lyp:this-file))
-    (current-dir  (dirname current-file))
+    (current-dir  (lyp:this-dir))
     (abs-path     (if (lyp:absolute-path? path)
                       path
                       (lyp:expand-path (lyp:join-path current-dir path))))
@@ -164,8 +161,6 @@ pincludeOnce = #(define-void-function (parser location path)(string?) (let* (
         (format "File not found ~a" abs-path) #f))
 
     (hash-set! lyp:file-included? abs-path #t)
-    (set! lyp:last-this-file abs-path)
-    (lyp:do-include parser abs-path)
-    (set! lyp:last-this-file current-file)
+    (lyp:include-string (lyp:fmt-include abs-path))
   )
 )))

data/lib/lyp/lilypond.rb

@@ -4,6 +4,59 @@ require 'ruby-progressbar'
 
 module Lyp::Lilypond
   class << self
+    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
+        else
+          argv_clean << arg
+        end
+      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])
+        end
+        Lyp::Lilypond.force_version!(opts[:use_version])
+      end
+      Lyp::Lilypond.check_lilypond!
+      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'."
+          exit 1
+        end
+      end
+    rescue => e
+      STDERR.puts e.message
+      exit 1
+    end
+    
     def compile(argv, opts = {})
       unless argv.last == '-'
         fn = Lyp.wrap(argv.pop, opts)

data/lib/lyp/resolver.rb

@@ -2,6 +2,7 @@ class Lyp::Resolver
   def initialize(user_file, opts = {})
     @user_file = user_file
     @opts = opts
+    @ext_require = @opts[:ext_require]
   end
   
   # Resolving package dependencies involves two stages:
@@ -25,7 +26,8 @@ class Lyp::Resolver
       user_file: @user_file,
       definite_versions: definite_versions,
       package_refs: refs,
-      package_dirs: dirs
+      package_dirs: dirs,
+      preload: @opts[:ext_require]
     }
   end
   
@@ -88,37 +90,18 @@ class Lyp::Resolver
     ly_content.scan(DEP_RE) do |type, ref|
       case type
       when INCLUDE, PINCLUDE, PINCLUDE_ONCE
-        # a package would normally use a plain \pinclude or \pincludeOnce
-        # command to include package files, e.g. \pinclude "inc/init.ly".
-        # 
-        # But a package can also qualify the file reference with the package
-        # name, in order to be able to load files after the package has already
-        # been loaded, e.g. \pinclude "mypack:inc/init.ly"
-        if ref =~ /^([^\:]+)\:(.+)$/
-          # ignore null package (used for testing purposes only)
-          next if $1 == 'null'
-          ref = $2
-        end
-        qualified_path = File.expand_path(ref, dir)
-        queue_file_for_processing(qualified_path, tree, leaf)
+        process_include_command(ref, dir, tree, leaf, opts)
       when REQUIRE
-        forced_path = nil
-        if ref =~ /^([^\:]+)\:(.+)$/
-          ref = $1
-          forced_path = File.expand_path($2, dir)
-        end
-
-        ref =~ Lyp::PACKAGE_RE
-        package, version = $1, $2
-        next if package == 'null'
-
-        # set forced path if applicable
-        if forced_path
-          set_forced_package_path(tree, package, forced_path)
-        end
+        process_require_command(ref, dir, tree, leaf, opts)
+      end
+    end
 
-        find_package_versions(ref, tree, leaf, opts)
+    # process any external requires (supplied using the -r command line option)
+    if @ext_require
+      @ext_require.each do |p|
+        process_require_command(p, dir, tree, leaf, opts)
       end
+      @ext_require = nil
     end
     
     tree[:processed_files][path] = true
@@ -126,6 +109,41 @@ class Lyp::Resolver
     raise "Cannot find file #{path}"
   end
   
+  def process_include_command(ref, dir, tree, leaf, opts)
+    # a package would normally use a plain \pinclude or \pincludeOnce
+    # command to include package files, e.g. \pinclude "inc/init.ly".
+    # 
+    # But a package can also qualify the file reference with the package
+    # name, in order to be able to load files after the package has already
+    # been loaded, e.g. \pinclude "mypack:inc/init.ly"
+    if ref =~ /^([^\:]+)\:(.+)$/
+      # ignore null package (used for testing purposes only)
+      return if $1 == 'null'
+      ref = $2
+    end
+    qualified_path = File.expand_path(ref, dir)
+    queue_file_for_processing(qualified_path, tree, leaf)
+  end
+  
+  def process_require_command(ref, dir, tree, leaf, opts)
+    forced_path = nil
+    if ref =~ /^([^\:]+)\:(.+)$/
+      ref = $1
+      forced_path = File.expand_path($2, dir)
+    end
+
+    ref =~ Lyp::PACKAGE_RE
+    package, version = $1, $2
+    return if package == 'null'
+
+    # set forced path if applicable
+    if forced_path
+      set_forced_package_path(tree, package, forced_path)
+    end
+
+    find_package_versions(ref, tree, leaf, opts)
+  end
+  
   def queue_file_for_processing(path, tree, leaf)
     (tree[:queue] ||= []) << {path: path, leaf: leaf}
   end

data/lib/lyp/templates/deps_wrapper.rb

@@ -50,10 +50,21 @@ _[:package_dirs].each do |package, path|
   (hash-set! lyp:package-dirs "{{package}}" {{quote_path[path]}})`
 end
 
-
 `
 )
 
 #(ly:debug "package loader is ready")
+`
+
+if _[:preload]
+  _[:preload].each do |package|
+`
+\require "{{package}}"
+`
+  end
+end
+
+`
 \include {{quote_path[user_filename]}}
-`
+`
+

data/lib/lyp/version.rb

@@ -1,3 +1,3 @@
 module Lyp
-  VERSION = "0.3.5"
+  VERSION = "0.3.6"
 end

data/lib/lyp/wrapper.rb

@@ -6,7 +6,7 @@ module Lyp
   ))
   
   def self.wrap(fn, opts = {})
-    r = Lyp::Resolver.new(fn).resolve_package_dependencies
+    r = Lyp::Resolver.new(fn, opts).resolve_package_dependencies
 
     # copy current_package_dir option
     r[:current_package_dir] = opts[:current_package_dir]
@@ -15,6 +15,7 @@ module Lyp
     fn = "#{Lyp::TMP_ROOT}/wrappers/#{File.basename(fn)}" 
   
     File.open(fn, 'w+') {|f| f << WRAPPER_TEMPLATE.render(r)}
+    
     fn
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lyp-win
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.6
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-01 00:00:00.000000000 Z
+date: 2016-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient