lyp-win 0.2.2

data/bin/install_release.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+
+shopt -s extglob
+set -o errtrace
+set -o errexit
+
+fail() { log "\nERROR: $*\n" ; exit 1 }
+has() { type "$1" > /dev/null 2>&1 }
+
+download() {
+  if has "curl"; then
+    curl -L -o $*
+  elif has "wget"; then
+    wget -O $*
+  else
+    fail "Could not find curl or wget"
+  fi
+}
+    
+WORKDIR="/tmp/lyp-release-installer"
+LYP_VERSION="0.2.2"
+URL_BASE="https://github.com/noteflakes/lyp/releases/download/v$LYP_VERSION"
+
+PLATFORM=`uname -sp`
+case $PLATFORM in
+  "Linux x86_64")
+    RELEASE_FILE="lyp-$LYP_VERSION-linux-x86_64"
+    ;;
+  "Linux x86")
+    RELEASE_FILE="lyp-$LYP_VERSION-linux-x86"
+    ;;
+  "Darwin i386")
+    RELEASE_FILE="lyp-$LYP_VERSION-osx"
+    ;;
+  *)
+    fail "Unspported platform $PLATFORM"
+esac
+
+RELEASE_URL="$URL_BASE/$RELEASE_FILE.tar.gz"
+RELEASE_PATH="$WORKDIR/$RELEASE_FILE"
+
+rm -rf $WORKDIR
+mkdir $WORKDIR
+echo "Downloading $RELEASE_URL"
+download "$WORKDIR/release.tar.gz" $RELEASE_URL
+echo "Extracting $WORKDIR/release.tar.gz"
+tar -xzf "$WORKDIR/release.tar.gz" -C $WORKDIR
+
+$RELEASE_PATH/bin/lyp install self
+
+rm -rf $WORKDIR

data/bin/lilypond

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+
+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
+
+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
+
+if $options[:raw]
+  exec("#{$lilypond_path} #{$argv[1..-1].join(' ')}")
+end
+
+OVERRIDING_LILYPOND_SWITCHES = %w{
+  -w --warranty
+  -v --version
+  scheme-sandbox
+}
+LILYPOND_HELP_SWITCHES = %w{
+  -h --help
+}
+LYP_LY_HELP = <<EOF
+Lyp-provided options:
+  -r, --raw                           run raw lilypond (no pre-processing)
+  -E, --env                           use version specified in $LILYPOND_VERSION
+  -u, --use=VERSION                   use the given version of lilypond
+  -n, --install                       install the given version if not found
+EOF
+
+case $argv.first
+when nil, *OVERRIDING_LILYPOND_SWITCHES
+  STDERR.puts "Lyp version #{Lyp::VERSION}"
+  exec("#{$lilypond_path} #{$argv.join(' ')}")
+  
+when *LILYPOND_HELP_SWITCHES
+  STDERR.puts "Lyp version #{Lyp::VERSION}"
+  puts `#{$lilypond_path} #{$argv.join(' ')}`
+  puts LYP_LY_HELP
+else
+  begin
+    Lyp::Lilypond.compile($argv, $options)
+  end
+end

data/bin/lyp

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

data/bin/release_wrapper_lilypond.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+set -e
+
+# Figure out where this script is located.
+SELFDIR="`dirname \"$0\"`"
+ROOTDIR="`cd \"$SELFDIR/..\" && pwd`"
+
+# Tell Bundler where the Gemfile and gems are.
+export BUNDLE_GEMFILE="$ROOTDIR/lib/vendor/Gemfile"
+unset BUNDLE_IGNORE_CONFIG
+
+# Run the actual app using the bundled Ruby interpreter, with Bundler activated.
+exec "$ROOTDIR/lib/ruby/bin/ruby" -rbundler/setup  -rreadline -I$ROOTDIR/lib/app/lib "$ROOTDIR/lib/app/bin/lilypond" "$@"

data/bin/release_wrapper_lyp.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+set -e
+
+# Figure out where this script is located.
+SELFDIR="`dirname \"$0\"`"
+ROOTDIR="`cd \"$SELFDIR/..\" && pwd`"
+
+# Tell Bundler where the Gemfile and gems are.
+export BUNDLE_GEMFILE="$ROOTDIR/lib/vendor/Gemfile"
+unset BUNDLE_IGNORE_CONFIG
+
+# Run the actual app using the bundled Ruby interpreter, with Bundler activated.
+exec "$ROOTDIR/lib/ruby/bin/ruby" -rbundler/setup  -rreadline -I$ROOTDIR/lib/app/lib "$ROOTDIR/lib/app/bin/lyp" "$@"

data/lib/lyp.rb

@@ -0,0 +1,42 @@
+$WINDOWS = Gem.win_platform?
+
+# test for existence of 
+$rugged_available = begin
+  gem 'rugged', '>=0.23.0'
+  require 'rugged'
+rescue Exception
+  nil
+end
+
+$git_available = `git --version` rescue nil
+
+unless $rugged_available || $git_available
+  raise "Lyp needs git in order to be able to install packages. Please install git and then try again."
+end
+
+unless $rugged_available
+  require 'lyp/git_based_rugged'
+end
+
+require 'tmpdir'
+require 'fileutils'
+$TMP_DIR = $WINDOWS ? "#{Dir.home}/AppData/Local/Temp" : "/tmp"
+$TMP_ROOT = "#{$TMP_DIR}/lyp"
+FileUtils.mkdir_p($TMP_ROOT)
+
+%w{
+  base
+  system
+  settings
+  
+  template
+  resolver
+  wrapper
+  
+  package
+  lilypond
+}.each do |f|
+  require File.expand_path("lyp/#{f}", File.dirname(__FILE__))
+end
+
+require File.expand_path("lyp/windows", File.dirname(__FILE__)) if $WINDOWS

data/lib/lyp/base.rb

@@ -0,0 +1,51 @@
+require 'fileutils'
+
+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 = /^([^@\>~]+)(?:@)?((?:\>=|~\>)?.+)?/
+  LILYPOND_RE = /^lilypond(?:@?((?:\>=|~\>)?.+))?/
+
+  LYP_DIRECTORY = File.expand_path('~/.lyp')
+  LYP_BIN_DIRECTORY = File.join(LYP_DIRECTORY, 'bin')
+  LYP_LIB_DIRECTORY = File.join(LYP_DIRECTORY, 'lib')
+  DEFAULT_PACKAGE_DIRECTORY = File.join(LYP_DIRECTORY, 'packages')
+  DEFAULT_LILYPONDS_DIRECTORY = File.join(LYP_DIRECTORY, 'lilyponds')
+  
+  # Fonts are installed on lilypond >= 2.18.2
+  FONT_COPY_REQ = Gem::Requirement.new('>=2.18.2')
+  FONT_PATCH_REQ = Gem::Requirement.new('>=2.18.2', '<2.19.12')
+  
+  # Font patch filename (required for 2.18.2 <= lilypond < 2.19.12)
+  FONT_PATCH_FILENAME = File.expand_path('etc/font.scm', File.dirname(__FILE__))
+
+  # 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__))
+  
+  LILYPOND_NOT_FOUND_MSG = "No version of lilypond found.\nTo install lilypond run 'lyp install lilypond'"
+
+  SETTINGS_FILENAME = 'settings.yml'
+  
+  def self.packages_dir
+    ensure_dir(DEFAULT_PACKAGE_DIRECTORY)
+  end
+  
+  def self.lilyponds_dir
+    ensure_dir(DEFAULT_LILYPONDS_DIRECTORY)
+  end
+
+  def self.settings_file
+    ensure_dir(LYP_DIRECTORY)
+    File.join(LYP_DIRECTORY, SETTINGS_FILENAME)
+  end
+  
+  def self.ensure_dir(dir)
+    FileUtils.mkdir_p(dir) unless File.directory?(dir)
+    dir
+  end
+end
+

data/lib/lyp/cli.rb

@@ -0,0 +1,314 @@
+require 'thor'
+require 'lyp/version'
+
+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
+
+$cmd_options = {}
+
+class Lyp::CLI < Thor
+  package_name "lyp"
+  map "-v" => :version
+  check_unknown_options! :except => :compile
+  class_option :verbose, aliases: '-V', :type => :boolean
+  
+  desc "version", "show Lyp version"
+  def version
+    $stderr.puts "Lyp #{Lyp::VERSION}"
+  end
+  
+  desc "search [PATTERN|lilypond]", "List available packages matching PATTERN or versions of lilypond"
+  def search(pattern = '')
+    $cmd_options = options
+
+    pattern =~ Lyp::PACKAGE_RE
+    package, version = $1, $2
+    
+    if package == 'lilypond'
+      search_lilypond(version)
+    else
+      search_package(pattern)
+    end
+  end  
+  
+  no_commands do
+    def search_lilypond(version)
+      versions = Lyp::Lilypond.search(version)
+  
+      if versions.empty?
+        puts "\nNo available versions of lilypond@#{version} found\n\n"
+      else
+        puts "\nAvailable versions of lilypond@#{version}:\n\n"
+        versions.each do |v|
+          prefix = v[:installed] ? " * " : "   "
+          puts "#{prefix}#{v[:version]}"
+        end
+        puts "\n * Currently installed\n\n"
+      end
+    end
+  
+    def search_package(pattern)
+      packages = Lyp::Package.list_lyp_index(pattern)
+      if packages.empty?
+        puts "\nNo matching package found in lyp-index\n\n"
+      else
+        puts "\nAvailable packages on lyp-index:\n\n"
+        packages.each do |p|
+          puts "   #{p[:name]}"
+        end
+        puts "\n\n"
+      end
+    end
+  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
+
+    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
+
+    # check lilypond default / current settings
+    Lyp::Lilypond.check_lilypond!
+    
+    $stderr.puts "Lyp #{Lyp::VERSION}"
+    Lyp::System.test_installed_status!
+    Lyp::Lilypond.compile(args)
+  end
+  
+  desc "test [<option>...] [.|PATTERN]", "Runs package tests on installed packages or local directory"
+  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 test(*args)
+    $cmd_options = options
+
+    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
+
+    # check lilypond default / current settings
+    Lyp::Lilypond.check_lilypond!
+    
+    $stderr.puts "Lyp #{Lyp::VERSION}"
+    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)
+    $cmd_options = options
+
+    raise "No package specified" if args.empty?
+    
+    args.each do |package|
+      case package
+      when 'self'
+        Lyp::System.install!
+      when Lyp::LILYPOND_RE
+        Lyp::System.test_installed_status!
+        Lyp::Lilypond.install($1, options)
+      else
+        Lyp::System.test_installed_status!
+        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)
+    $cmd_options = options
+
+    Lyp::System.test_installed_status!
+
+    raise "No package specified" if args.empty?
+    args.each do |package|
+      case package
+      when 'self'
+        Lyp::System.uninstall!
+      when Lyp::LILYPOND_RE
+        Lyp::System.test_installed_status!
+        Lyp::Lilypond.uninstall($1, options)
+      else
+        Lyp::System.test_installed_status!
+        Lyp::Package.uninstall(package, options)
+      end
+    end
+  end
+  
+  desc "use [lilypond@]<VERSION>", "Switch version of lilypond"
+  method_option :default, aliases: '-d', type: :boolean, desc: 'Set default lilypond version'
+  def use(version)
+    $cmd_options = options
+
+    Lyp::System.test_installed_status!
+
+    if version =~ Lyp::LILYPOND_RE
+      version = $1
+    end
+  
+    lilypond = Lyp::Lilypond.use(version, options)
+    puts "Using version #{lilypond[:version]}"
+  end
+
+  desc "list [PATTERN|lilypond]", "List installed packages matching PATTERN or versions of lilypond"
+  def list(pattern = nil)
+    $cmd_options = options
+
+    Lyp::System.test_installed_status!
+
+    if pattern == 'lilypond'
+      list = Lyp::Lilypond.list
+      if list.empty?
+        puts Lyp::LILYPOND_NOT_FOUND_MSG
+      else
+        puts LILYPOND_PREAMBLE
+        list.each {|info| puts format_lilypond_entry(info)}
+        puts LILYPOND_LEGEND
+      end
+    else
+      list = Lyp::Package.list(args.first)
+      if list.empty?
+        if args.first
+          return puts "\nNo installed packages found matching '#{args.first}'\n\n"
+        else
+          return puts "\nNo packages are currently installed\n\n"
+        end
+      end
+      
+      by_package = list.inject({}) do |m, p|
+        p =~ Lyp::PACKAGE_RE; (m[$1] ||= []) << $2; m
+      end
+      
+      puts "\nInstalled packages:\n\n"
+      by_package.keys.sort.each do |p|
+        puts "   #{p} => (#{by_package[p].sort.join(', ')})"
+      end
+      puts "\n\n"
+    end
+  end
+  
+  desc "which [PATTERN|lilypond]", "List locations of installed packages matching PATTERN or versions of lilypond"
+  def which(pattern = nil)
+    $cmd_options = options
+
+    Lyp::System.test_installed_status!
+
+    if pattern == 'lilypond'
+      current = Lyp::Lilypond.current_lilypond
+      if current
+        puts Lyp::Lilypond.current_lilypond
+      else
+        puts Lyp::LILYPOND_NOT_FOUND_MSG
+      end
+    else
+      Lyp::Package.which(args.first).each {|p| puts p}
+    end
+  end
+  
+  desc "deps FILE", "Lists dependencies found in user's files"
+  def deps(fn)
+    $cmd_options = options
+
+    resolver = Lyp::Resolver.new(fn)
+    tree = resolver.get_dependency_tree(ignore_missing: true)
+    tree[:dependencies].each do |package, leaf|
+      versions = leaf[:versions].keys.map {|k| k =~ Lyp::PACKAGE_RE; $2 }.sort
+      if versions.empty?
+        puts "   #{leaf[:clause]} => (no local version found)"
+      else
+        puts "   #{leaf[:clause]} => #{versions.join(', ')}"
+      end
+    end
+  end
+  
+  desc "resolve FILE", "Resolves and installs missing dependencies found in user's files"
+  method_option :all, aliases: '-a', type: :boolean, desc: 'Install all found dependencies'
+  def resolve(fn)
+    $cmd_options = options
+
+    resolver = Lyp::Resolver.new(fn)
+    tree = resolver.get_dependency_tree(ignore_missing: true)
+    tree[:dependencies].each do |package, leaf|
+      if options[:all] || leaf[:versions].empty?
+        Lyp::Package.install(leaf[:clause])
+      end
+    end
+  end
+end
+
+begin
+  Lyp::CLI.start(ARGV)
+rescue => e
+  puts e.message
+  puts e.backtrace.join("\n") if $cmd_options[:verbose]
+  exit(1)
+end