lyp 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 95a3a0c7bde875ba4dc99f647f476f3c38c38edc
-  data.tar.gz: a2b2624b43aa5ce75c697c5f3fb29dd3b8141ca9
+  metadata.gz: be34fcbc627f99a4a4e3859e3c3629f69604a621
+  data.tar.gz: 7141ac8c3ec2d892218022810877584f05b2afb2
 SHA512:
-  metadata.gz: 787384a486ddbb0f561404513cbda77fc783d5430428669d31021bf3c84878692fb4d13a2ee4bb0fe3a900ba46aa6711cf1815232b573272ca7b067d36cb12d9
-  data.tar.gz: 0dd250c4b5ce752610d59a17f14de1da74d7d91268cea0fb37cb90767a4395b74cefe88ce4d8a8865651d29c3fe2a45cb0d848d0668858567adad06be5b5872b
+  metadata.gz: 1bfb4b6e26d1b552613791a58bfdeb9a65c338cf62efaa0cce537361d06a6fbc0b65f2c8bc422242f8707061a7f3541898fcb6cdc7701f3c873d96b1affc9f8e
+  data.tar.gz: 66b0af75bb43ee1fca671ccd967ec046971320a28dc30d4c5ed71dc19b99ae59f5ee5f7974a43c505e6a6d88962374149f7f2a2483eb5882da4b136d20bd4f6b

data/lib/lyp/base.rb

@@ -21,9 +21,13 @@ module Lyp
   
   # Font patch filename (required for 2.18.2 <= lilypond < 2.19.12)
   FONT_PATCH_FILENAME = File.expand_path('etc/font.scm', File.dirname(__FILE__))
-  
-  SETTINGS_FILENAME = 'settings.yml'
 
+  # etc/lyp.ly contains lyp:* procedure definitions for loading packages and
+  # other support code.
+  LYP_LY_LIB_PATH = File.expand_path('etc/lyp.ly', File.dirname(__FILE__))
+
+  SETTINGS_FILENAME = 'settings.yml'
+  
   def self.packages_dir
     ensure_dir(DEFAULT_PACKAGE_DIRECTORY)
   end

data/lib/lyp/etc/lyp.ly

@@ -0,0 +1,97 @@
+#(begin
+  ; 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)))
+    )
+    (string-append 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 (string-append 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/lilypond.rb

@@ -485,15 +485,18 @@ module Lyp::Lilypond
       FileUtils.rm_rf(lilypond_dir)
     end
     
-    def exec(cmd)
+    def exec(cmd, raise_on_failure = true)
+      success = nil
       Open3.popen3(cmd) do |_in, _out, _err, wait_thr|
         exit_value = wait_thr.value
         $_out = _out.read
         $_err = _err.read
-        if exit_value != 0
-          raise "Error executing cmd #{cmd}: #{$_err.read}"
-        end
+        success = exit_value == 0
+      end
+      if !success && raise_on_failure
+        raise "Error executing cmd #{cmd}: #{$_err}"
       end
+      success
     end
   end
 end

data/lib/lyp/package.rb

@@ -410,13 +410,15 @@ module Lyp::Package
       yield stats
       
       if stats[:test_count] == 0
-        STDERR.puts "No test files found"
+        STDERR.puts "No test files found" unless opts[:silent]
       else
         puts "\nFinished in %.2g seconds\n%d files, %d failures" % [
           Time.now - stats[:start], stats[:test_count], stats[:fail_count]
-        ]
-        exit(stats[:fail_count] > 0 ? 1 : 0)
+          ] unless opts[:silent]
+        exit(stats[:fail_count] > 0 ? 1 : 0) unless opts[:dont_exit]
       end
+      
+      stats
     end
     
     def perform_test(fn, stats)
@@ -426,14 +428,13 @@ module Lyp::Package
       end
     end
     
-    
-    def run_package_tests(patterns)
+    def run_package_tests(patterns, opts = {})
       patterns = [''] if patterns.empty?
       packages = patterns.inject([]) do |m, pat|
         m += Dir["#{Lyp.packages_dir}/#{pat}*"]
       end.uniq
       
-      run_tests do |stats|
+      run_tests(opts) do |stats|
         packages.each do |path|
           files = Dir["#{path}/**/*_test.ly"]
           next if files.empty?

data/lib/lyp/resolver.rb

@@ -12,22 +12,27 @@ class Lyp::Resolver
     
     definite_versions = resolve_tree(tree)
     specifier_map = map_specifiers_to_versions(tree)
+    
+    refs, dirs = {}, {}
+    definite_versions.each do |v|
+      package = v =~ Lyp::PACKAGE_RE && $1
 
+      specifier_map[package].each_key {|s| refs[s] = package}
+      dirs[package] = File.dirname(tree[:available_packages][v][:path])
+    end
+    
     {
       user_file: @user_file,
       definite_versions: definite_versions,
-      package_paths: definite_versions.inject({}) do |h, v|
-        package = v =~ Lyp::PACKAGE_RE && $1
-        path = tree[:available_packages][v][:path]
-        specifier_map[package].each_key {|s| h[s] = path}
-        h
-      end
+      package_refs: refs,
+      package_dirs: dirs
     }
   end
   
-  DEP_RE = /\\(require|include|pinclude) "([^"]+)"/.freeze
+  DEP_RE = /\\(require|include|pinclude|pincludeOnce) "([^"]+)"/.freeze
   INCLUDE = "include".freeze
   PINCLUDE = "pinclude".freeze
+  PINCLUDE_ONCE = "pincludeOnce".freeze
   REQUIRE = "require".freeze
   
   # Each "leaf" on the dependency tree is a hash of the following structure:
@@ -80,13 +85,39 @@ class Lyp::Resolver
     dir = File.dirname(path)
     
     # Parse lilypond file for \include and \require
-    ly_content.scan(DEP_RE) do |type, path|
+    ly_content.scan(DEP_RE) do |type, ref|
       case type
-      when INCLUDE, PINCLUDE
-        qualified_path = File.expand_path(path, dir)
+      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)
       when REQUIRE
-        find_package_versions(path, 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
+        next 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
     end
     
@@ -166,11 +197,19 @@ class Lyp::Resolver
     tree[:available_packages] ||= get_available_packages(Lyp.packages_dir)
   end
   
+  def set_forced_package_path(tree, package, path)
+    @opts[:forced_package_paths] ||= {}
+    @opts[:forced_package_paths][package] = path
+    
+    available_packages(tree)["#{package}@forced"] = {
+      path: File.join(path, MAIN_PACKAGE_FILE),
+      dependencies: {}
+    }
+  end
+  
   # Return a hash of all packages found in the packages directory, creating a
   # leaf for each package
   def get_available_packages(dir)
-    forced_paths = @opts[:forced_package_paths] || {}
-    
     packages = Dir["#{Lyp.packages_dir}/*"].inject({}) do |m, p|
       name = File.basename(p)
       
@@ -181,11 +220,15 @@ class Lyp::Resolver
       m
     end
 
-    forced_paths.each do |package, path|
-      packages["#{package}@forced"] = {
-        path: File.join(path, MAIN_PACKAGE_FILE),
-        dependencies: {}
-      }
+    forced_paths = @opts[:forced_package_paths] || {}
+    
+    if @opts[:forced_package_paths]
+      @opts[:forced_package_paths].each do |package, path|
+        packages["#{package}@forced"] = {
+          path: File.join(path, MAIN_PACKAGE_FILE),
+          dependencies: {}
+        }
+      end
     end
     
     packages

data/lib/lyp/templates/deps_wrapper.rb

@@ -25,104 +25,29 @@ current_package_dir = _[:current_package_dir] || FileUtils.pwd
 # lyp:file-included       - a hash table for keeping track of include files
 
 `
+#(ly:set-option 'relative-includes #t)
+\include "{{Lyp::LYP_LY_LIB_PATH}}"
+
 #(begin
   (define lyp:input-filename "{{user_filename}}")
   (define lyp:input-dirname "{{user_dirname}}")
   (define lyp:current-package-dir "{{current_package_dir}}")
-  (define lyp:package-refs (make-hash-table))`
+`
 
-_[:package_paths].each do |spec, path|
+_[:package_refs].each do |spec, path|
 `
   (hash-set! lyp:package-refs "{{spec}}" "{{path}}")`
 end
 
-# package-loaded is hash table used for tracking loaded packages, so each
-# package is loaded only once.
-
-# package-loaded is hash table used for tracking loaded packages, so each
-# package is loaded only once.
-
-`
-  (define lyp:package-loaded (make-hash-table))
-  (define lyp:file-included (make-hash-table))
-)
-`
-
-# define the \require command for loading packages
-`
-require = #(define-void-function (parser location package)(string?)
-  (let* 
-    (
-      (path (hash-ref lyp:package-refs package))
-      (loaded? (hash-ref lyp:package-loaded path))
-      (package-dir (dirname path))
-      (prev-package-dir lyp:current-package-dir)
-    )
-    (if (and path (not loaded?)) (begin
-      (if (not (file-exists? path)) (
-        (ly:error "Failed to load package ~a (file not found ~a)" package path)
-      ))
-      (ly:debug "Loading package ~a at ~a" package package-dir)
-      (set! lyp:current-package-dir package-dir)
-      (hash-set! lyp:package-loaded path #t)
-      #{ \include #path #}
-      (set! lyp:current-package-dir prev-package-dir)
-    ))
-  )
-)
+_[:package_dirs].each do |package, path|
 `
+  (hash-set! lyp:package-dirs "{{package}}" "{{path}}")`
+end
 
-# define the \pinclude command for including files inside the current package
-
-`
-pinclude = #(define-void-function (parser location path)(string?)
-  (let* 
-    (
-      (full-path (format "~a/~a" lyp:current-package-dir path))
-    )
-    (begin
-      (if (not (file-exists? full-path)) (
-        (ly:error "File not found ~a" full-path)
-      ))
-      (hash-set! lyp:file-included full-path #t)
-      #{ \include #full-path #}
-    )
-  )
-)
-
-pincludeOnce = #(define-void-function (parser location path)(string?)
-  (let* 
-    (
-      (full-path (format "~a/~a" lyp:current-package-dir path))
-      (loaded? (hash-ref lyp:file-included full-path))
-    )
-    (if (and full-path (not loaded?)) (begin
-      (if (not (file-exists? full-path)) (
-        (ly:error "File not found ~a" full-path)
-      ))
-      (hash-set! lyp:file-included full-path #t)
-      #{ \include #full-path #}
-    ))
-  )
-)
-`
 
-# define the \pload scheme function, for loading scheme files inside the current
-# package
 `
-#(define (pload path)
-  (let* 
-    (
-      (full-path (format "~a/~a" lyp:current-package-dir path))
-    )
-    (load full-path)
-  )
 )
-`
 
-# load the user's file
-`
-#(ly:set-option 'relative-includes #t)
 #(ly:debug "package loader is ready")
 \include "{{user_filename}}"
 `

data/lib/lyp/version.rb

@@ -1,3 +1,3 @@
 module Lyp
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/lib/lyp/wrapper.rb

@@ -11,7 +11,7 @@ module Lyp
     # copy current_package_dir option
     r[:current_package_dir] = opts[:current_package_dir]
 
-    if !r[:package_paths].empty? || opts[:force_wrap]
+    if !r[:package_dirs].empty? || opts[:force_wrap]
       FileUtils.mkdir_p('/tmp/lyp/wrappers')
       fn = "/tmp/lyp/wrappers/#{File.basename(fn)}" 
   

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lyp
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-27 00:00:00.000000000 Z
+date: 2016-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: highline
@@ -137,6 +137,7 @@ files:
 - lib/lyp/base.rb
 - lib/lyp/cli.rb
 - lib/lyp/etc/font.scm
+- lib/lyp/etc/lyp.ly
 - lib/lyp/git_based_rugged.rb
 - lib/lyp/lilypond.rb
 - lib/lyp/package.rb