lyp 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 237b06c5018520e73c24a410d350343e806dd4c5
-  data.tar.gz: 67060615bc34efded14ca9ff3b1e8b9134c2f414
+  metadata.gz: be14f9ec309c846d05866736f78ba82458ba4f5b
+  data.tar.gz: b5ffae67c9ef47ec416ec61d763913cdc89b9459
 SHA512:
-  metadata.gz: 4b9325b66427152575d3b7340c7bfea283cad9816d4a330defe75ab88ee6e2d9610b888e1a57b3010dd839455f794b344f7df18e2d3c96b81156edef5701db4b
-  data.tar.gz: cfa5bf20c687e24c95a2b7c225b0fb2afe00ffe34e8e06c19b12df583d42458173f3b0adfb9929f84357a80b9d2818174e5e3e588d2f32145a2c1a38b3f5a977
+  metadata.gz: d5899a965576c65a6d07bd07ff716889e85042044d2efdbf8d16d47adfe09e57965479b75873a0ef0b5ae1c0b293529268fbe28472e97c7a360695df5b5b3e04
+  data.tar.gz: a075ab18c0270b3c057db6ae9c3f365f9c8b4c26c7cf1df4c89fd79c6e896f495cfcc5356cf8c301c93aaa8833df16e5a40bf795112899fd88b344ea7b87bf10

data/README.md

@@ -1,4 +1,4 @@
-[![Build Status](https://travis-ci.org/ciconia/lyp.svg?branch=master)](https://travis-ci.org/ciconia/lyp)
+[![Build Status](https://travis-ci.org/noteflakes/lyp.svg?branch=master)](https://travis-ci.org/noteflakes/lyp)
 
 # lyp - a package manager for lilypond
 

data/bin/lilypond

@@ -1,9 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'lyp/version'
-require 'lyp/directories'
-require 'lyp/settings'
-require 'lyp/lilypond'
+require 'lyp'
 
 STDERR.puts "Lyp version #{Lyp::VERSION}"
 
@@ -24,8 +22,8 @@ else
   
   begin
     Lyp::Lilypond.compile(ARGV)
-  rescue => e
-    STDERR.puts e.message
-    exit 1
+  # rescue => e
+  #   STDERR.puts e.message
+  #   exit 1
   end
 end

data/lib/lyp/cli/commands.rb

@@ -45,7 +45,7 @@ command :list do |c|
     Lyp::System.test_installed_status!
 
     pattern = args.first
-    if pattern.nil? || pattern == 'lilypond'
+    if pattern == 'lilypond'
       STDOUT.puts LILYPOND_PREAMBLE
       Lyp::Lilypond.list.each {|info| puts format_lilypond_entry(info)}
       STDOUT.puts LILYPOND_LEGEND
@@ -64,9 +64,6 @@ command :compile do |c|
     begin
       raise "File not specified" if args.empty?
       Lyp::Lilypond.compile(ARGV[1..-1])
-    rescue => e
-      STDERR.puts e.message
-      exit 1
     end
   end
 end
@@ -78,13 +75,35 @@ command :search do |c|
     Lyp::System.test_installed_status!
 
     pattern = args.first
-    if pattern == 'lilypond'
+    pattern =~ Lyp::PACKAGE_RE
+    package, version = $1, $2
+    req = (version && Gem::Requirement.new(version)) rescue nil
+    
+    if package == 'lilypond'
       begin
-        versions = Lyp::Lilypond.search
-        versions.each {|v| puts v}
-      rescue => e
-        STDERR.puts e.message
-        exit 1
+        versions = Lyp::Lilypond.search(version)
+        
+        if versions.empty?
+          puts "\nNo versions of lilypond are available for download\n\n"
+        else
+          puts "\nAvailable versions of lilypond:\n\n"
+          versions.each do |v|
+            prefix = v[:installed] ? " * " : "   "
+            puts "#{prefix}#{v[:version]}"
+          end
+          puts "\n * Currently installed\n\n"
+        end
+      end
+    else
+      packages = Lyp::Package.list_lyp_index(pattern)
+      if packages.empty?
+        puts "\nNo matching package found in lyp-index\n\n"
+      else
+        puts "\nAvailable packages:\n\n"
+        packages.each do |p|
+          puts "   #{p[:name]}"
+        end
+        puts "\n\n"
       end
     end
   end
@@ -106,11 +125,11 @@ command :install do |c|
         when /^lilypond(?:@(.+))?$/
           Lyp::System.test_installed_status!
           Lyp::Lilypond.install($1, opts.__hash__)
+        else
+          Lyp::System.test_installed_status!
+          Lyp::Package.install(package)
         end
       end
-    # rescue => e
-    #   STDERR.puts e.message
-    #   exit 1
     end
   end
 end
@@ -131,9 +150,6 @@ command :use do |c|
       
       lilypond = Lyp::Lilypond.use(version, opts.__hash__)
       puts "Using version #{lilypond[:version]}"
-    rescue => e
-      STDERR.puts e.message
-      exit 1
     end
   end
 end
@@ -157,9 +173,6 @@ command :uninstall do |c|
           Lyp::Lilypond.uninstall($1)
         end
       end
-    rescue => e
-      STDERR.puts e.message
-      exit 1
     end
   end
 end

data/lib/lyp/lilypond.rb

@@ -8,7 +8,6 @@ module Lyp::Lilypond
       argv << fn
       
       invoke(argv)
-      exec("#{current_lilypond} #{argv.join(' ')}")
     end
     
     def invoke(argv)
@@ -142,7 +141,7 @@ module Lyp::Lilypond
     BASE_URL = "http://download.linuxaudio.org/lilypond/binaries"
   
     # Returns a list of versions of lilyponds available for download
-    def search
+    def search(version_specifier = nil)
       require 'open-uri'
       require 'nokogiri'
 
@@ -156,19 +155,39 @@ module Lyp::Lilypond
           versions << $1
         end
       end
-      versions
+
+      installed_versions = list.map {|l| l[:version]}
+      versions.select {|v| version_match(v, version_specifier, versions)}.map do |v|
+        {
+          version: v,
+          installed: installed_versions.include?(v)
+        }
+      end
+    end
+    
+    def version_match(version, specifier, all_versions)
+      case specifier
+      when 'latest'
+        version == all_versions.last
+      when 'stable'
+        Gem::Version.new(version).segments[1].even?
+      when 'unstable'
+        Gem::Version.new(version).segments[1].odd?
+      else
+        Gem::Requirement.new(specifier) =~ Gem::Version.new(version)
+      end
     end
     
     def latest_stable_version
-      search.reverse.find {|l| Gem::Version.new(l).segments[1] % 2 == 0}
+      search.reverse.find {|l| Gem::Version.new(l[:version]).segments[1].even?}[:version]
     end
     
     def latest_unstable_version
-      search.reverse.find {|l| Gem::Version.new(l).segments[1] % 2 != 0}
+      search.reverse.find {|l| Gem::Version.new(l[:version]).segments[1].odd?}[:version]
     end
     
     def latest_version
-      search.last
+      search.last[:version]
     end
     
     def install(version_specifier, opts = {})
@@ -195,10 +214,13 @@ module Lyp::Lilypond
         latest_version
       else
         req = Gem::Requirement.new(version_specifier)
-        search.reverse.find {|v| req =~ Gem::Version.new(v)}
+        lilypond = search.reverse.find {|l| req =~ Gem::Version.new(l[:version])}
+        if lilypond
+          lilypond[:version]
+        else
+          raise "Could not find version matching #{version_specifier}"
+        end
       end
-    rescue => e
-      raise "Invalid version specified: #{version_specifier}"
     end
     
     def detect_lilypond_platform
@@ -339,11 +361,11 @@ module Lyp::Lilypond
         lilypond = lilypond_list.first
       when 'stable'
         lilypond = lilypond_list.find do |v|
-          Gem::Version.new(v[:version]).segments[1] % 2 == 0
+          Gem::Version.new(v[:version]).segments[1].even?
         end
       when 'unstable'
         lilypond = lilypond_list.find do |v|
-          Gem::Version.new(v[:version]).segments[1] % 2 != 0
+          Gem::Version.new(v[:version]).segments[1].odd?
         end
       else
         version = "~>#{version}.0" if version =~ /^\d+\.\d+$/
@@ -382,7 +404,14 @@ module Lyp::Lilypond
     end
     
     def exec(cmd)
-      raise unless system(cmd)
+      Open3.popen3(cmd) do |_in, _out, _err, wait_thr|
+        exit_value = wait_thr.value
+        if exit_value != 0
+          raise "Error executing cmd #{cmd}: #{_err.read}"
+        end
+      end
+      
+      # raise unless system(cmd)
     end
   end
 end

data/lib/lyp/package.rb

@@ -1,3 +1,8 @@
+require 'fileutils'
+require 'rugged'
+require 'open-uri'
+require 'yaml'
+
 module Lyp::Package
   class << self
     
@@ -14,15 +19,198 @@ 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)
-        y_version = y_version && Gem::Version.new(y_version)
+        x_version = (x_version && Gem::Version.new(x_version) rescue x)
+        y_version = (y_version && Gem::Version.new(y_version) rescue y)
 
-        if x_package == y_package
+        if (x_package == y_package) && (x_version.class == y_version.class)
           x_version <=> y_version
         else
-          x_package <=> y_package
+          x <=> y
         end
       end
     end
+    
+    def install(package_specifier, opts = {})
+      unless package_specifier =~ Lyp::PACKAGE_RE
+        raise "Invalid package specifier #{package_specifier}"
+      end
+      package, version = $1, $2
+      
+      url = package_git_url(package)
+      tmp_path = git_url_to_temp_path(url)
+      
+      repo = package_repository(url, tmp_path, opts)
+      version = checkout_package_version(repo, version, opts)
+      
+      # Copy files
+      package_path = git_url_to_package_path(
+        package !~ /\// ? package : url, version
+      )
+      
+      FileUtils.mkdir_p(File.dirname(package_path))
+      FileUtils.rm_rf(package_path)
+      FileUtils.cp_r(tmp_path, package_path)
+      
+      install_package_dependencies(package_path, opts)
+      
+      puts "\nInstalled #{package}@#{version}\n\n" unless opts[:silent]
+      
+      # return the installed version
+      version
+    end
+    
+    def package_repository(url, tmp_path, opts = {})
+      # Create repository
+      if File.directory?(tmp_path)
+        repo = Rugged::Repository.new(tmp_path)
+        repo.fetch('origin', [repo.head.name])
+      else
+        FileUtils.mkdir_p(File.dirname(tmp_path))
+        puts "Cloning #{url}..." unless opts[:silent]
+        repo = Rugged::Repository.clone_at(url, tmp_path)
+      end
+      repo
+    end
+    
+    def checkout_package_version(repo, version, opts = {})
+      # Select commit to checkout
+      if version.nil? || (version == '')
+        puts "Checkout master branch..." unless opts[:silent]
+        repo.checkout('master', strategy: :force)
+        version = 'head'
+      else
+        tag = select_git_tag(repo, version)
+        unless tag
+          raise "Could not find tag matching #{version_specifier}"
+        end
+        puts "Checkout #{tag.name} tag" unless opts[:silent]
+        repo.checkout(tag.name, strategy: :force)
+        version = tag_version(tag)
+      end
+      version
+    end
+    
+    def install_package_dependencies(package_path, opts = {})
+      # Install any missing sub-dependencies
+      sub_deps = []
+      
+      resolver = Lyp::Resolver.new("#{package_path}/package.ly")
+      deps_tree = resolver.get_dependency_tree(ignore_missing: true)
+      deps_tree[:dependencies].each do |package_name, leaf|
+        sub_deps << leaf[:clause] if leaf[:versions].empty?
+      end
+      sub_deps.each {|d| install(d, opts)}
+    end
+    
+    def package_git_url(package, search_index = true)
+      case package
+      when /^(?:(?:[^\:]+)|http|https)\:/
+        package
+      when /^([^\.]+\..+)\/[^\/]+\/.+(?<!\.git)$/ # .git missing from end of URL
+        "https://#{package}.git"
+      when /^([^\.]+\..+)\/.+/
+        "https://#{package}"
+      when /^[^\/]+\/[^\/]+$/
+        "https://github.com/#{package}.git"
+      else
+        if search_index && (url = search_lyp_index(package))
+          package_git_url(url, false) # make sure url is qualified
+        else
+          raise "Invalid package specified"
+        end
+      end
+    end
+    
+    LYP_INDEX_URL = "https://raw.githubusercontent.com/noteflakes/lyp-index/master/index.yaml"
+    
+    def search_lyp_index(package)
+      entry = lyp_index['packages'][package]
+      entry && entry['url']
+    end
+    
+    def list_lyp_index(pattern = nil)
+      list = lyp_index['packages'].inject([]) do |m, kv|
+        m << kv[1].merge(name: kv[0])
+      end
+      
+      if pattern
+        list.select! {|p| p[:name] =~ /#{pattern}/}
+      end
+      
+      list.sort_by {|p| p[:name]}
+    end
+    
+    def lyp_index
+      @lyp_index ||= YAML.load(open(LYP_INDEX_URL))
+    end
+    
+    TEMP_REPO_ROOT_PATH = "/tmp/lyp/repos"
+
+    def git_url_to_temp_path(url)
+      case url
+      when /^(?:http|https)\:(?:\/\/)?(.+)$/
+        path = $1.gsub(/\.git$/, '')
+        "#{TEMP_REPO_ROOT_PATH}/#{path}"
+      when /^(?:.+@)([^\:]+)\:(?:\/\/)?(.+)$/
+        domain, path = $1, $2.gsub(/\.git$/, '')
+        "#{TEMP_REPO_ROOT_PATH}/#{domain}/#{path}"
+      else
+        raise "Invalid URL #{url}"
+      end
+    end
+    
+    def git_url_to_package_path(url, version)
+      version = 'head' if version.nil? || (version == '')
+      
+      case url
+      when /^(?:http|https)\:(?:\/\/)?(.+)$/
+        path = $1.gsub(/\.git$/, '')
+        "#{Lyp::packages_dir}/#{path}@#{version}"
+      when /^(?:.+@)([^\:]+)\:(?:\/\/)?(.+)$/
+        domain, path = $1, $2.gsub(/\.git$/, '')
+        "#{Lyp::packages_dir}/#{domain}/#{path}@#{version}"
+      else
+        if url !~ /\//
+          "#{Lyp::packages_dir}/#{url}@#{version}"
+        else
+          raise "Invalid URL #{url}"
+        end
+      end
+    end
+    
+    TAG_VERSION_RE = /^v?(\d.*)$/
+    
+    def select_git_tag(repo, version_specifier)
+      return if version_specifier.nil? || (version_specifier == '')
+      
+      req = Gem::Requirement.new(version_specifier) rescue nil
+      
+      repo_tags(repo).reverse.find do |t|
+        if req && (v = tag_version(t))
+          req =~ Gem::Version.new(v)
+        else
+          t.name == version_specifier
+        end
+      end
+    end
+    
+    # Returns a list of tags sorted by version
+    def repo_tags(repo)
+      tags = []
+      repo.tags.each {|t| tags << t}
+      
+      tags.sort do |x, y|
+        x_version, y_version = tag_version(x), tag_version(y)
+        if x_version && y_version
+          Gem::Version.new(x_version) <=> Gem::Version.new(y_version)
+        else
+          x.name <=> y.name
+        end
+      end
+    end
+    
+    def tag_version(tag)
+      (tag.name =~ TAG_VERSION_RE) ? $1 : nil
+    end
   end
 end

data/lib/lyp/resolver.rb

@@ -43,7 +43,7 @@ class Lyp::Resolver
   #
   # Since files to be processed are added to a queue, this method loops through
   # the queue until it's empty.
-  def get_dependency_tree
+  def get_dependency_tree(opts = {})
     tree = {
       dependencies: {},
       queue: [],
@@ -53,11 +53,13 @@ class Lyp::Resolver
     queue_file_for_processing(@user_file, tree, tree)
 
     while job = pull_file_from_queue(tree)
-      process_lilypond_file(job[:path], tree, job[:leaf])
+      process_lilypond_file(job[:path], tree, job[:leaf], opts)
     end
     
-    squash_old_versions(tree)
-    remove_unfulfilled_dependencies(tree)
+    unless opts[:ignore_missing]
+      squash_old_versions(tree)
+      remove_unfulfilled_dependencies(tree)
+    end
     
     tree
   end
@@ -68,7 +70,7 @@ class Lyp::Resolver
   #
   # The leaf argument is a pointer to the current leaf on the tree on which to
   # add dependencies. This is how transitive dependencies are represented.
-  def process_lilypond_file(path, tree, leaf)
+  def process_lilypond_file(path, tree, leaf, opts)
     # path is expected to be absolute
     return if tree[:processed_files][path]
     
@@ -82,7 +84,7 @@ class Lyp::Resolver
         qualified_path = File.expand_path(path, dir)
         queue_file_for_processing(qualified_path, tree, leaf)
       when REQUIRE
-        find_package_versions(path, tree, leaf)
+        find_package_versions(path, tree, leaf, opts)
       end
     end
     
@@ -101,7 +103,7 @@ class Lyp::Resolver
   
   # Find available packaging matching the package specifier, and queue them for
   # processing any include files or transitive dependencies.
-  def find_package_versions(ref, tree, leaf)
+  def find_package_versions(ref, tree, leaf, opts)
     return {} unless ref =~ Lyp::PACKAGE_RE
     ref_package = $1
     version_clause = $2
@@ -109,7 +111,7 @@ class Lyp::Resolver
     matches = find_matching_packages(ref, tree)
     
     # Raise if no match found and we're at top of the tree
-    if matches.empty? && (tree == leaf)
+    if matches.empty? && (tree == leaf) && !opts[:ignore_missing]
       raise "No package found for requirement #{ref}"
     end
     
@@ -137,9 +139,13 @@ class Lyp::Resolver
     req = Gem::Requirement.new(req_version || '>=0')
 
     available_packages(tree).select do |package, sub_tree|
-      if package =~ Lyp::PACKAGE_RE
-        version = Gem::Version.new($2 || '0')
-        (req_package == $1) && (req =~ version)
+      if (package =~ Lyp::PACKAGE_RE) && (req_package == $1)
+        version = Gem::Version.new($2 || '0') rescue nil
+        if version.nil?
+          req_version.nil? || (req_version == $2)
+        else
+          req =~ version
+        end
       else
         nil
       end

data/lib/lyp/templates/deps_wrapper.rb

@@ -11,8 +11,7 @@
 # package-refs is a hash table with an entry for each package reference made
 # using \require, either in user files or in package files (for transitive dependencies).
 
-`\version "2.19.31"
-
+`
 #(begin
   (define package-refs (make-hash-table))`
 
@@ -54,5 +53,5 @@ require = #(define-void-function (parser location package)(string?)
 `
 #(ly:debug "package loader is ready")
 #(ly:set-option 'relative-includes #t)
-\include "{{_[:user_file]}}"
+\include "{{File.expand_path(_[:user_file])}}"
 `

data/lib/lyp/version.rb

@@ -1,3 +1,3 @@
 module Lyp
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/lyp/wrapper.rb

@@ -1,14 +1,19 @@
 require 'tempfile'
 
 module Lyp
+  WRAPPER_TEMPLATE = Lyp::Template.new(IO.read(
+    File.expand_path('templates/deps_wrapper.rb', File.dirname(__FILE__))
+  ))
+  
   def self.wrap(fn)
     r = Lyp::Resolver.new(fn).resolve_package_dependencies
 
     unless r[:package_paths].empty?
-      fn = Tempfile.new('lyp-deps-wrapper.ly').path
+      FileUtils.mkdir_p('/tmp/lyp/wrappers')
+      fn = "/tmp/lyp/wrappers/#{File.basename(fn)}" 
+           #Tempfile.new('lyp-deps-wrapper.ly').path
   
-      t = Lyp::Template.new(IO.read(File.expand_path('templates/deps_wrapper.rb', File.dirname(__FILE__))))
-      File.open(fn, 'w+') {|f| f << t.render(r)}
+      File.open(fn, 'w+') {|f| f << WRAPPER_TEMPLATE.render(r)}
     end
     fn
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lyp
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-08 00:00:00.000000000 Z
+date: 2016-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: highline
@@ -110,6 +110,26 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.7.1
+- !ruby/object:Gem::Dependency
+  name: rugged
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.23.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.23.3
 description: Lyp is a tool for managing lilypond versions and lilypond packages
 email: ciconia@gmail.com
 executables:
@@ -135,7 +155,7 @@ files:
 - lib/lyp/templates/deps_wrapper.rb
 - lib/lyp/version.rb
 - lib/lyp/wrapper.rb
-homepage: http://github.com/ciconia/lyp
+homepage: http://github.com/noteflakes/lyp
 licenses:
 - MIT
 metadata: {}