lyp 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8cd933e97beb1cd0fd6fbb50a34c2eead1141ef3
-  data.tar.gz: b0a2289da1f2688a4b91fdeb619572c53b6aab17
+  metadata.gz: f05a307478b3335dc0caa9e0d687b73ec0a1f4f3
+  data.tar.gz: e6811cd8a83c6b05a068ac1b494c41cd0f023917
 SHA512:
-  metadata.gz: ade7918db91666a7386a9d8b1fdd5f93a8347d30b08d0528faee0ca7d44c4347f4ae03f335f65941ba441a0b771c12ce383b4e0d06e57d3a06e2471f3f490e5d
-  data.tar.gz: 53970054a2052fa366d1e9a7d28c5698167921a4b1666b622a8c325ce31c504ec38345858c7d295733805b9f714ce404bf28f56f113806a07d2b6600d755f12f
+  metadata.gz: 76e91e59d3b126e5e002d7ff0e2df0983a0c59ed72bffd444615fe35a811a8bae2a9e5768aebb5a82372cc245a93bc1bc85250354b79ea87a87f862952f5b0e4
+  data.tar.gz: 471fa1026b5a75d2f4de797117c0f5cfb37872e97ef72b67b7e5855ebc9960ba5c06741f2723f74c97761e9bc77b931173e2b0f963a121da6ddefe8cbdd036b2

data/lib/lyp/base.rb

@@ -6,7 +6,7 @@ module Lyp
   # before the version number.
   # 
   # Accepted operators: >=, ~>
-  PACKAGE_RE = /^([^@\>~]+)(?:@?((?:\>=|~\>)?.+))?/
+  PACKAGE_RE = /^([^@\>~]+)(?:@)?((?:\>=|~\>)?.+)?/
   LILYPOND_RE = /^lilypond(?:@?((?:\>=|~\>)?.+))?/
 
   LYP_DIRECTORY = File.expand_path('~/.lyp')

data/lib/lyp/cli.rb

@@ -113,9 +113,10 @@ class Lyp::CLI < Thor
     Lyp::Lilypond.compile(args)
   end
   
-  desc "test [<option>...]", "Runs package tests on local directory"
+  desc "test [<option>...] [.|PATTERN]", "Runs package tests on installed packages or local directory"
   method_option :install, aliases: '-i', 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 :all, aliases: '-a', type: :boolean, desc: ''
   def test(*args)
     $stderr.puts "Lyp #{Lyp::VERSION}"
 
@@ -129,11 +130,17 @@ class Lyp::CLI < Thor
       Lyp::Lilypond.check_lilypond!
     end
     
-    Lyp::Package.run_tests('.')
+    case args
+    when ['.']
+      Lyp::Package.run_local_tests('.')
+    else
+      Lyp::Package.run_package_tests(args)
+    end
   end
 
   desc "install <PACKAGE|lilypond|self>...", "Install a package or a version of lilypond. When 'install self' is invoked, lyp installs itself in ~/.lyp."
   method_option :default, aliases: '-d', type: :boolean, desc: 'Set default lilypond version'
+  method_option :test, aliases: '-t', type: :boolean, desc: 'Run package tests after installation'
   def install(*args)
     raise "No package specified" if args.empty?
     
@@ -146,12 +153,13 @@ class Lyp::CLI < Thor
         Lyp::Lilypond.install($1, options)
       else
         Lyp::System.test_installed_status!
-        Lyp::Package.install(package)
+        Lyp::Package.install(package, options)
       end
     end
   end
 
   desc "uninstall <PACKAGE|lilypond|self>...", "Uninstall a package or a version of lilypond. When 'uninstall self' is invoked, lyp uninstalls itself from ~/.lyp."
+  method_option :all, aliases: '-a', type: :boolean, desc: 'Uninstall all versions'
   def uninstall(*args)
     Lyp::System.test_installed_status!
 
@@ -165,7 +173,7 @@ class Lyp::CLI < Thor
         Lyp::Lilypond.uninstall($1)
       else
         Lyp::System.test_installed_status!
-        Lyp::Package.uninstall(package)
+        Lyp::Package.uninstall(package, options)
       end
     end
   end

data/lib/lyp/lilypond.rb

@@ -6,7 +6,7 @@ require 'ruby-progressbar'
 module Lyp::Lilypond
   class << self
     def compile(argv, opts = {})
-      fn = Lyp.wrap(argv.pop)
+      fn = Lyp.wrap(argv.pop, opts)
       argv << fn
       
       invoke(argv, opts)

data/lib/lyp/package.rb

@@ -74,6 +74,12 @@ module Lyp::Package
       
       puts "\nInstalled #{package}@#{info[:version]}\n\n" unless opts[:silent]
       
+      if opts[:test]
+        FileUtils.cd(info[:path]) do
+          run_tests(info[:path])
+        end
+      end
+      
       # important: return the installed version
       info[:version]
     end
@@ -147,20 +153,38 @@ module Lyp::Package
         package !~ /\// ? package : package_git_url(package), nil
       )
       
-      if opts[:all_versions]
+      if opts[:all]
         Dir["#{package_path}@*"].each do |path|
           name = path.gsub("#{Lyp.packages_dir}/", '')
           puts "Uninstalling #{name}" unless opts[:silent]
           FileUtils.rm_rf(path)
         end
       else
-        package_path += "@#{version}"
+        if version
+          package_path += "@#{version}"
+        else
+          packages = Dir["#{package_path}@*"] + Dir["#{package_path}"]
+          case packages.size
+          when 0
+            raise "Could not find package #{package}"
+          when 1
+            package_path = packages[0]
+          else
+            packages.each do |path|
+              name = path.gsub("#{Lyp.packages_dir}/", '')
+              puts "Uninstalling #{name}" unless opts[:silent]
+              FileUtils.rm_rf(path)
+            end
+            return
+          end
+        end
+        
         if File.directory?(package_path)
           name = package_path.gsub("#{Lyp.packages_dir}/", '')
           puts "Uninstalling #{name}" unless opts[:silent]
           FileUtils.rm_rf(package_path)
         else
-          raise "Could not find #{package}"
+          raise "Could not find package #{package}"
         end
       end
     end
@@ -363,27 +387,62 @@ module Lyp::Package
       (tag =~ TAG_VERSION_RE) ? $1 : nil
     end
     
-    def run_tests(dir, opts = {})
-      t1 = Time.now
-      test_count = 0
-      fail_count = 0
-      
-      Dir["#{dir}/**/*_test.ly"].each do |fn|
-        test_count += 1
-        
-        unless Lyp::Lilypond.compile([fn], mode: :system)
-          fail_count += 1
+    # Runs all tests found in local directory
+    def run_local_tests(dir, opts = {})
+      package_dir = File.expand_path(dir)
+      test_files = Dir["#{package_dir}/**/*_test.ly"]
+      run_tests(opts) do |stats|
+        test_files.each do |f|
+          perform_test(f, stats)
         end
       end
+    end
+    
+    # This method runs tests by yielding the test statistics.
+    # The caller should then call #perform_test to run each test file.
+    def run_tests(opts = {})
+      stats = {
+        start: Time.now,
+        test_count: 0,
+        fail_count: 0
+      }
       
-      if test_count == 0
+      yield stats
+      
+      if stats[:test_count] == 0
         STDERR.puts "No test files found"
       else
         puts "\nFinished in %.2g seconds\n%d files, %d failures" % [
-          Time.now - t1, test_count, fail_count
+          Time.now - stats[:start], stats[:test_count], stats[:fail_count]
         ]
-        exit(fail_count > 0 ? 1 : 0)
+        exit(stats[:fail_count] > 0 ? 1 : 0)
+      end
+    end
+    
+    def perform_test(fn, stats)
+      stats[:test_count] += 1
+      unless Lyp::Lilypond.compile([fn], mode: :system, force_wrap: true)
+        stats[:fail_count] += 1
       end
     end
+    
+    
+    def run_package_tests(patterns)
+      patterns = [''] if patterns.empty?
+      packages = patterns.inject([]) do |m, pat|
+        m += Dir["#{Lyp.packages_dir}/#{pat}*"]
+      end.uniq
+      
+      run_tests do |stats|
+        packages.each do |path|
+          files = Dir["#{path}/**/*_test.ly"]
+          next if files.empty?
+
+          FileUtils.cd(path) do
+            files.each {|fn| perform_test(fn, stats)}
+          end
+        end
+      end        
+    end
   end
 end

data/lib/lyp/resolver.rb

@@ -1,6 +1,7 @@
 class Lyp::Resolver
-  def initialize(user_file)
+  def initialize(user_file, opts = {})
     @user_file = user_file
+    @opts = opts
   end
   
   # Resolving package dependencies involves two stages:
@@ -108,7 +109,7 @@ class Lyp::Resolver
     return {} unless ref =~ Lyp::PACKAGE_RE
     ref_package = $1
     version_clause = $2
-
+    
     matches = find_matching_packages(ref, tree)
     
     # Raise if no match found and we're at top of the tree
@@ -137,12 +138,17 @@ class Lyp::Resolver
     
     req_package = $1
     req_version = $2
-    req = Gem::Requirement.new(req_version || '>=0')
 
+    req = nil
+    if @opts[:forced_package_paths] && @opts[:forced_package_paths][req_package]
+      req_version = 'forced'
+    end
+    
+    req = Gem::Requirement.new(req_version || '>=0') rescue nil
     available_packages(tree).select do |package, sub_tree|
       if (package =~ Lyp::PACKAGE_RE) && (req_package == $1)
         version = Gem::Version.new($2 || '0') rescue nil
-        if version.nil?
+        if version.nil? || req.nil?
           req_version.nil? || (req_version == $2)
         else
           req =~ version
@@ -163,14 +169,26 @@ class Lyp::Resolver
   # Return a hash of all packages found in the packages directory, creating a
   # leaf for each package
   def get_available_packages(dir)
-    Dir["#{Lyp.packages_dir}/*"].inject({}) do |m, p|
-      m[File.basename(p)] = {
+    forced_paths = @opts[:forced_package_paths] || {}
+    
+    packages = Dir["#{Lyp.packages_dir}/*"].inject({}) do |m, p|
+      name = File.basename(p)
+      
+      m[name] = {
         path: File.join(p, MAIN_PACKAGE_FILE), 
-        dependencies: {},
-        
+        dependencies: {}
       }
       m
     end
+
+    forced_paths.each do |package, path|
+      packages["#{package}@forced"] = {
+        path: File.join(path, MAIN_PACKAGE_FILE),
+        dependencies: {}
+      }
+    end
+    
+    packages
   end
 
   # Recursively remove any dependency for which no version is locally 
@@ -391,7 +409,7 @@ class Lyp::Resolver
     
     map = lambda do |m, p|
       if p =~ Lyp::PACKAGE_RE
-        m[$1] = versions[p] ||= Gem::Version.new($2 || '0.0')
+        m[$1] = versions[p] ||= (Gem::Version.new($2 || '0.0') rescue nil)
       end
       m
     end

data/lib/lyp/templates/deps_wrapper.rb

@@ -12,6 +12,8 @@ require 'fileutils'
 user_filename = File.expand_path(_[:user_file])
 user_dirname = File.dirname(user_filename)
 
+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
@@ -28,7 +30,7 @@ user_dirname = File.dirname(user_filename)
   (define lyp-input-filename "{{user_filename}}")
   (define lyp-input-dirname "{{user_dirname}}")
   (define lyp-cwd "{{FileUtils.pwd}}")
-  (define lyp-current-package-dir "")
+  (define lyp-current-package-dir "{{current_package_dir}}")
   (define lyp-package-refs (make-hash-table))`
 
 _[:package_paths].each do |spec, path|
@@ -107,6 +109,7 @@ pinclude = #(define-void-function (parser location path)(string?)
 
 # 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.1.7"
+  VERSION = "0.1.8"
 end

data/lib/lyp/wrapper.rb

@@ -5,13 +5,15 @@ module Lyp
     File.expand_path('templates/deps_wrapper.rb', File.dirname(__FILE__))
   ))
   
-  def self.wrap(fn)
+  def self.wrap(fn, opts = {})
     r = Lyp::Resolver.new(fn).resolve_package_dependencies
 
-    unless r[:package_paths].empty?
+    # copy current_package_dir option
+    r[:current_package_dir] = opts[:current_package_dir]
+
+    if !r[:package_paths].empty? || opts[:force_wrap]
       FileUtils.mkdir_p('/tmp/lyp/wrappers')
       fn = "/tmp/lyp/wrappers/#{File.basename(fn)}" 
-           #Tempfile.new('lyp-deps-wrapper.ly').path
   
       File.open(fn, 'w+') {|f| f << WRAPPER_TEMPLATE.render(r)}
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lyp
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-26 00:00:00.000000000 Z
+date: 2016-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: highline