lyp 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 381c017e254a433f1b75547cfbe8d775edd1b620
+  data.tar.gz: 522058c1cbed06a7d28ef1b04cd1d88d68b5be9b
+SHA512:
+  metadata.gz: 9f4452b8c6d711749aa7b81afe594401321e61afdc1eb914c8b8dc49608e7230a44886be47cb7aec57738613d4ac2300a7596ad407d88e4e173e88660b2269d7
+  data.tar.gz: b390a85bcb6a7e5f2e7fae3b903705546c63a066086be50f8903f59f95bd983fc855c5c1f5a6ad05e8fa03ffc5947ca26daae1b881b3ec934cddc9b81cc86915

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Sharon Rosner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,9 @@
+[![Build Status](https://travis-ci.org/ciconia/lyp.svg?branch=master)](https://travis-ci.org/ciconia/lyp)
+
+# lyp
+
+lyp is a package manager for lilypond.
+
+Initial spec is [here](https://github.com/ciconia/lyp/wiki/General-spec).
+
+

data/bin/lilypond

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require File.expand_path("../lib/lyp/version", File.dirname(__FILE__))
+
+require File.expand_path("../lib/lyp/directories", File.dirname(__FILE__))
+require File.expand_path("../lib/lyp/settings", File.dirname(__FILE__))
+require File.expand_path("../lib/lyp/lilypond", File.dirname(__FILE__))
+
+lilypond_path = Lyp::Lilypond.current_lilypond
+
+if (ARGV == ['-v']) || (ARGV == ['--warranty'])
+  puts "Lyp version #{Lyp::VERSION}"
+  # Show lilypond version and exit
+  exec("#{lilypond_path} #{ARGV.join(' ')}")
+end
+
+if ARGV.size == 0
+  exec(lilypond_path)
+else
+  
+  begin
+    Lyp::Lilypond.compile(ARGV)
+  rescue => e
+    STDERR.puts e.message
+    exit 1
+  end
+end

data/bin/lyp

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require "lyp/cli"
+

data/lib/lyp.rb

@@ -0,0 +1,16 @@
+%w{
+  output
+  env
+  
+  directories
+  settings
+  
+  template
+  resolver
+  wrapper
+  
+  package
+  lilypond
+}.each do |f|
+  require File.expand_path("lyp/#{f}", File.dirname(__FILE__))
+end

data/lib/lyp/cli.rb

@@ -0,0 +1,32 @@
+require "lyp"
+require "lyp/version"
+
+INSTALL_MSG = <<EOF
+Lyp is currently not installed. In order to use lyp, ~/.lyp/bin has to
+be included in the shell $PATH.
+EOF
+
+# test installation
+unless Lyp::ENV.installed?
+  require 'highline'
+
+  cli = HighLine.new
+  STDERR.puts INSTALL_MSG.gsub("\n", " ")
+
+  if cli.agree("Would you like to install lyp now? (yes/no)")
+    Lyp::ENV.install!
+    STDERR.puts "To finish installation please open a new shell"
+    exit
+  end
+end
+
+require 'commander/import'
+
+program :name,            'lyp'
+program :version,         Lyp::VERSION
+program :description,     'Lyp is a package manager for lilypond.'
+program :help_formatter,  :compact
+
+require 'lyp/cli/commands'
+
+default_command(:list)

data/lib/lyp/cli/commands.rb

@@ -0,0 +1,146 @@
+# package commands
+
+def lilypond_prefix(info)
+  if info[:current] && info[:default]
+    "=* "
+  elsif info[:current]
+    "=> "
+  elsif info[:default]
+    " * "
+  else
+    "   "
+  end
+end
+
+def lilypond_postfix(info)
+  if info[:system]
+    " (system)"
+  else
+    ""
+  end
+end
+
+def format_lilypond_entry(info)
+  "#{lilypond_prefix(info)}#{info[:version]}#{lilypond_postfix(info)}"
+end
+
+LILYPOND_PREAMBLE = <<EOF
+
+Lilypond versions:
+
+EOF
+
+LILYPOND_LEGEND = <<EOF
+
+# => - current
+# =* - current && default
+#  * - default
+
+EOF
+
+command :list do |c|
+  c.syntax =      "list [PATTERN]"
+  c.description = "Lists installed versions of packages whose name matches PATTERN"
+  c.action do |args, opts|
+    pattern = args.first
+    if pattern.nil? || pattern == 'lilypond'
+      STDOUT.puts LILYPOND_PREAMBLE
+      Lyp::Lilypond.list.each {|info| puts format_lilypond_entry(info)}
+      STDOUT.puts LILYPOND_LEGEND
+    else
+      Lyp::Package.list(args.first).each {|p| puts p}
+    end
+  end
+end
+
+command :compile do |c|
+  c.syntax = "compile <FILE>"
+  c.description = "Resolves package dependencies and invokes lilypond"
+  c.action do |args, opts|
+    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
+
+command :search do |c|
+  c.syntax = "search <PATTERN>"
+  c.description = "Search for a package or a version of lilypond"
+  c.action do |args, opts|
+    pattern = args.first
+    if pattern == 'lilypond'
+      begin
+        versions = Lyp::Lilypond.search
+        versions.each {|v| puts v}
+      rescue => e
+        STDERR.puts e.message
+        exit 1
+      end
+    end
+  end
+end
+
+command :install do |c|
+  c.syntax = "install <PACKAGE...>"
+  c.description = "Install a package or a version of lilypond"
+  c.option "-d", "--default", "Set default version"
+  c.action do |args, opts|
+    begin
+      raise "No package specified" if args.empty?
+      
+      args.each do |package|
+        if package =~ /^lilypond(?:@(.+))?$/
+          Lyp::Lilypond.install($1, opts.__hash__)
+        end
+      end
+    rescue => e
+      STDERR.puts e.message
+      exit 1
+    end
+  end
+end
+
+command :use do |c|
+  c.syntax = "use [lilypond@]<VERSION>"
+  c.description = "Switch version of lilypond"
+  c.option "-d", "--default", "Set default version"
+
+  c.action do |args, opts|
+    begin
+      version = args.first
+      if version =~ /^lilypond@(.+)$/
+        version = $1
+      end
+      
+      lilypond = Lyp::Lilypond.use(version, opts.__hash__)
+      puts "Using version #{lilypond[:version]}"
+    rescue => e
+      STDERR.puts e.message
+      exit 1
+    end
+  end
+end
+
+command :uninstall do |c|
+  c.syntax = "uninstall <PACKAGE>"
+  c.description = "Uninstall a package or version of lilypond"
+
+  c.action do |args, opts|
+    begin
+      raise "No package specified" if args.empty?
+      
+      args.each do |package|
+        if package =~ /^lilypond(?:@(.+))?$/
+          Lyp::Lilypond.uninstall($1)
+        end
+      end
+    rescue => e
+      STDERR.puts e.message
+      exit 1
+    end
+  end
+end

data/lib/lyp/directories.rb

@@ -0,0 +1,26 @@
+module Lyp
+  # A package specifier is of the form <package>@<version specifier>, where
+  # the version specifier can be simply a version number, or include an operator
+  # before the version number. Accepted operators: >=, ~>
+  PACKAGE_RE = /^([^@]+)(?:@(.+))?$/
+
+  LYPACK_DIRECTORY = File.expand_path('~/.lyp')
+  LYPACK_BIN_DIRECTORY = File.join(LYPACK_DIRECTORY, 'bin')
+  DEFAULT_PACKAGE_DIRECTORY = File.join(LYPACK_DIRECTORY, 'packages')
+  DEFAULT_LILYPONDS_DIRECTORY = File.join(LYPACK_DIRECTORY, 'lilyponds')
+  
+  SETTINGS_FILENAME = 'settings.yml'
+
+  def self.packages_dir
+    DEFAULT_PACKAGE_DIRECTORY
+  end
+  
+  def self.lilyponds_dir
+    DEFAULT_LILYPONDS_DIRECTORY
+  end
+
+  def self.settings_file
+    File.join(LYPACK_DIRECTORY, SETTINGS_FILENAME)
+  end
+end
+

data/lib/lyp/env.rb

@@ -0,0 +1,32 @@
+module Lyp::ENV
+  class << self
+    PROFILE_FILES = %w{
+      .profile .bash_profile .bash_login .bashrc .zshenv .zshrc .mkshrc
+    }.map {|fn| File.join(Dir.home, fn)}
+
+    LYPACK_LOAD_CODE = <<EOF
+
+[[ ":${PATH}:" == *":${HOME}/.lyp/bin:"* ]] || PATH="$HOME/.lyp/bin:$PATH"
+EOF
+
+    def install!
+      # Install lyp in environment
+
+      PROFILE_FILES.each do |fn|
+        next unless File.file?(fn)
+        unless IO.read(fn) =~ /\.lyp\/bin/
+          begin
+            File.open(fn, 'a') {|f| f << LYPACK_LOAD_CODE}
+          rescue
+            # ignore
+          end
+        end
+      end
+    end
+    
+    def installed?
+      ":#{::ENV['PATH']}:" =~ /#{Lyp::LYPACK_BIN_DIRECTORY}/
+    end
+  end
+end
+

data/lib/lyp/lilypond.rb

@@ -0,0 +1,377 @@
+require 'httpclient'
+require 'uri'
+
+module Lyp::Lilypond
+  class << self
+    def compile(argv)
+      fn = Lyp.wrap(argv.pop)
+      argv << fn
+      
+      invoke(argv)
+      exec("#{current_lilypond} #{argv.join(' ')}")
+    end
+    
+    def invoke(argv)
+      lilypond = detect_use_version_argument(argv) || current_lilypond
+      
+      exec("#{lilypond} #{argv.join(' ')}")
+    end
+    
+    def detect_use_version_argument(argv)
+      nil
+    end
+    
+    def default_lilypond
+      Lyp::Settings['lilypond/default']
+    end
+    
+    def set_default_lilypond(path)
+      Lyp::Settings['lilypond/default'] = path
+    end
+    
+    # The current lilypond path is stored in a temporary file named by the 
+    # session id. Thus we can persist the version selected by the user
+    def current_lilypond
+      settings = get_session_settings
+
+      if !settings[:current]
+        settings[:current] = default_lilypond
+        set_session_settings(settings)
+      end
+      
+      settings[:current]
+    end
+    
+    def set_current_lilypond(path)
+      settings = get_session_settings
+      settings[:current] = path
+      set_session_settings(settings)
+    end
+    
+    def get_session_settings
+      YAML.load(IO.read(session_settings_filename)) rescue {}
+    end
+    
+    def set_session_settings(settings)
+      File.open(session_settings_filename, 'w+') do |f|
+        f << YAML.dump(settings)
+      end
+    end
+    
+    def session_settings_filename
+      "/tmp/lyp.session.#{Process.getsid}.yml"
+    end
+    
+    CMP_VERSION = proc do |x, y|
+      Gem::Version.new(x[:version]) <=> Gem::Version.new(y[:version])
+    end
+    
+    def list
+      system_list = system_lilyponds
+      lyp_list = lyp_lilyponds
+      
+      default = default_lilypond
+      unless default
+        latest = system_list.sort(&CMP_VERSION).last || lyp_list.sort(&CMP_VERSION).last
+        if latest
+          default = latest[:path]
+          set_default_lilypond(default)
+        end
+      end
+      current = current_lilypond
+      
+      lilyponds = system_list + lyp_list
+
+      lilyponds.each do |l|
+        l[:default] = l[:path] == default
+        l[:current] = l[:path] == current
+      end
+      
+      # sort by version
+      lilyponds.sort!(&CMP_VERSION)
+    end
+    
+    def lyp_lilyponds
+      list = []
+      
+      Dir["#{Lyp.lilyponds_dir}/*"].each do |path|
+        next unless File.directory?(path) && File.basename(path) =~ /^[\d\.]+$/
+        
+        version = File.basename(path)
+        path = File.join(path, "bin/lilypond")
+        list << {
+          path: path,
+          version: version
+        }
+      end
+      
+      list
+    end
+    
+    def system_lilyponds
+      list = get_system_lilyponds_paths
+      return list if list.empty?
+      
+      list.inject([]) do |m, path|
+        begin
+          resp = `#{path} -v`
+          if resp.lines.first =~ /LilyPond ([0-9\.]+)/i
+            m << {
+              path: path,
+              version: $1,
+              system: true
+            }
+          end
+        rescue
+          # ignore error
+        end
+        m
+      end
+    end
+    
+    def get_system_lilyponds_paths
+      list = `which -a lilypond`
+      list = list.lines.map {|f| f.chomp}.reject do |l|
+        l =~ /^#{Lyp::LYPACK_BIN_DIRECTORY}/
+      end
+    end
+    
+    BASE_URL = "http://download.linuxaudio.org/lilypond/binaries"
+  
+    # Returns a list of versions of lilyponds available for download
+    def search
+      require 'open-uri'
+      require 'nokogiri'
+
+      platform = detect_lilypond_platform
+      url = "#{BASE_URL}/#{platform}/"
+      doc = Nokogiri::HTML(open(url))
+      
+      versions = []
+      doc.xpath("//td//a").each do |a|
+        if a[:href] =~ /^lilypond-([0-9\.]+)/
+          versions << $1
+        end
+      end
+      versions
+    end
+    
+    def latest_stable_version
+      search.reverse.find {|l| Gem::Version.new(l).segments[1] % 2 == 0}
+    end
+    
+    def latest_unstable_version
+      search.reverse.find {|l| Gem::Version.new(l).segments[1] % 2 != 0}
+    end
+    
+    def latest_version
+      search.last
+    end
+    
+    def install(version_specifier, opts = {})
+      version = detect_version_from_specifier(version_specifier)
+      raise "No version found matching specifier #{version_specifier}" unless version
+
+      install_version(version, opts)
+
+      lilypond_path = "#{Lyp.lilyponds_dir}/#{version}/bin/lilypond"
+      set_current_lilypond(lilypond_path)
+      set_default_lilypond(lilypond_path) if opts[:default]
+    end
+    
+    def detect_version_from_specifier(version_specifier)
+      case version_specifier
+      when /^\d/
+        version_specifier
+      when 'stable'
+        latest_stable_version
+      when 'unstable'
+        latest_unstable_version
+      else
+        req = Gem::Requirement.new(version_specifier)
+        search.reverse.find {|v| req =~ Gem::Version.new(v)}
+      end
+    rescue => e
+      raise "Invalid version specified: #{version_specifier}"
+    end
+    
+    def detect_lilypond_platform
+      case RUBY_PLATFORM
+      when /x86_64-darwin/
+        "darwin-x86"
+      when /ppc-darwin/
+        "darwin-ppc"
+      when "i686-linux"
+        "linux-x86"
+      when "x86_64-linux"
+        "linux-64"
+      when "ppc-linux"
+        "linux-ppc"
+      end
+    end
+  
+    def install_version(version, opts)
+      platform = detect_lilypond_platform
+      url = lilypond_install_url(platform, version, opts)
+      fn = temp_install_filename(url)
+
+      download_lilypond(url, fn, opts) unless File.file?(fn)
+      install_lilypond_files(fn, platform, version, opts)
+    end
+
+    def lilypond_install_url(platform, version, opts)
+      ext = platform =~ /darwin/ ? ".tar.bz2" : ".sh"
+      filename = "lilypond-#{version}-1.#{platform}"
+    
+      "#{BASE_URL}/#{platform}/#{filename}#{ext}"
+    end
+    
+    def temp_install_filename(url)
+      u = URI(url)
+      "/tmp/lyp-installer-#{File.basename(u.path)}"
+    end
+  
+    def download_lilypond(url, fn, opts)
+      STDERR.puts "Downloading #{url}" unless opts[:silent]
+      
+      download_count = 0
+      client = HTTPClient.new
+      conn = client.get_async(url)
+      msg = conn.pop
+      total_size = msg.header['Content-Length'].first.to_i
+      io = msg.content
+
+      unless opts[:silent]
+        pbar = ProgressBar.create(title: 'Download', total: total_size)
+      end
+      File.open(fn, 'w+') do |f|
+        while data = io.read(10000)
+          download_count += data.bytesize
+          f << data
+          unless opts[:silent]
+            pbar.progress = download_count if download_count <= total_size
+          end
+        end
+      end
+      pbar.finish unless opts[:silent]
+    end
+  
+    def install_lilypond_files(fn, platform, version, opts)
+      case platform
+      when /darwin/
+        install_lilypond_files_osx(fn, version, opts)
+      when /linux/
+        install_lilypond_files_linux(fn, platform, version, opts)
+      end
+    end
+  
+    def install_lilypond_files_osx(fn, version, opts)
+      target = "/tmp/lyp/installer/lilypond"
+      FileUtils.mkdir_p(target)
+    
+      STDERR.puts "Extracting..." unless opts[:silent]
+      exec "tar -xjf #{fn} -C #{target}"
+    
+      copy_lilypond_files("#{target}/LilyPond.app/Contents/Resources", version, opts)
+    end
+  
+    def install_lilypond_files_linux(fn, platform, version, opts)
+      target = "/tmp/lyp/installer/lilypond"
+      FileUtils.mkdir_p(target)
+    
+      # create temp directory in which to untar file
+      tmp_dir = "/tmp/lyp/#{Time.now.to_f}"
+      FileUtils.mkdir_p(tmp_dir)
+    
+      FileUtils.cd(tmp_dir) do
+        exec "sh #{fn} --tarball"
+      end
+      
+      tmp_fn = "#{tmp_dir}/lilypond-#{version}-1.#{platform}.tar.bz2"
+      
+      STDERR.puts "Extracting..." unless opts[:silent]
+      exec "tar -xjf #{tmp_fn} -C #{target}"
+    
+      copy_lilypond_files("#{target}/usr", version, opts)
+    end
+
+    def copy_lilypond_files(base_path, version, opts)
+      target_dir = File.join(Lyp.lilyponds_dir, version)
+      
+      FileUtils.rm_rf(target_dir) if File.exists?(target_dir)
+      
+      # create directory for lilypond files
+      FileUtils.mkdir_p(target_dir)
+    
+      # copy files
+      STDERR.puts "Copying..." unless opts[:silent]
+      %w{bin etc lib lib64 share var}.each do |entry|
+        dir = File.join(base_path, entry)
+        FileUtils.cp_r(dir, target_dir, remove_destination: true) if File.directory?(dir)
+      end
+      
+      STDERR.puts exec "#{target_dir}/bin/lilypond -v"  unless opts[:silent]
+    rescue => e
+      puts e.message
+    end
+    
+    def use(version, opts)
+      lilypond_list = list.reverse
+      
+      case version
+      when 'system'
+        lilypond = lilypond_list.find {|v| v[:system] }
+        unless lilypond
+          raise "Could not find a system installed version of lilypond"
+        end
+      when 'latest'
+        lilypond = lilypond_list.first
+      when 'stable'
+        lilypond = lilypond_list.find do |v|
+          Gem::Version.new(v[:version]).segments[1] % 2 == 0
+        end
+      when 'unstable'
+        lilypond = lilypond_list.find do |v|
+          Gem::Version.new(v[:version]).segments[1] % 2 != 0
+        end
+      else
+        version = "~>#{version}.0" if version =~ /^\d+\.\d+$/
+        req = Gem::Requirement.new(version)
+        lilypond = lilypond_list.find {|v| req =~ Gem::Version.new(v[:version])}
+      end
+      
+      unless lilypond
+        raise "Could not find a lilypond matching \"#{version}\""
+      end
+      
+      set_current_lilypond(lilypond[:path])
+      set_default_lilypond(lilypond[:path]) if opts[:default]
+      
+      lilypond
+    end
+    
+    def uninstall(version)
+      lilyponds = list.reverse
+      lilypond = lilyponds.find {|l| l[:version] == version && !l[:system]}
+      unless lilypond
+        raise "Invalid version specified: #{version}"
+      end
+      lilyponds.delete(lilypond)
+      latest = lilyponds.first
+      
+      if lilypond[:default]
+        set_default_lilypond(latest && latest[:path])
+      end
+      if lilypond[:current]
+        set_current_lilypond(latest && latest[:path])
+      end
+      
+      lilypond_dir = File.expand_path('../..', lilypond[:path])
+      FileUtils.rm_rf(lilypond_dir)
+    end
+    
+    def exec(cmd)
+      raise unless system(cmd)
+    end
+  end
+end