lyp-win 0.2.2

data/lib/lyp/settings.rb

@@ -0,0 +1,37 @@
+require 'yaml'
+
+module Lyp::Settings
+  class << self
+    def get
+      YAML.load(IO.read(Lyp.settings_file)) rescue {}
+    end
+    
+    def set(o)
+      File.open(Lyp.settings_file, 'w+') {|f| f << YAML.dump(o)}
+    end
+    
+    def [](path)
+      h = get
+      while path =~ /^([^\/]+)\/(.+)$/
+        h = h[$1.to_sym] ||= {}
+        path = $2
+      end
+      
+      h[path.to_sym]
+    end
+    
+    def []=(path, value)
+      h = settings = get
+      while path =~ /^([^\/]+)\/(.+)$/
+        h = h[$1.to_sym] ||= {}
+        path = $2
+      end
+      
+      h[path.to_sym] = value
+      
+      set(settings)
+      
+      value
+    end
+  end
+end

data/lib/lyp/system.rb

@@ -0,0 +1,135 @@
+require 'fileutils'
+
+module Lyp::System
+  class << self
+    INSTALL_MSG = <<EOF
+
+Warning! Lyp is not yet properly installed in your home directory. 
+
+To install lyp run 'lyp install self'. lyp will then:
+  1. Setup ~/.lyp as its base directory.
+  2. Add the lyp and lilypond scripts to ~/.lyp/bin.
+  3. Add ~/.lyp/bin to front of $PATH.
+  
+You can uninstall lyp at any time by running 'lyp uninstall self'.
+
+EOF
+
+    def test_installed_status!
+      unless installed?
+        puts INSTALL_MSG
+      end
+    end
+    
+    def installed?(opts = {})
+      path_is_there = ":#{::ENV['PATH']}:" =~ /#{Lyp::LYP_BIN_DIRECTORY}/
+      file_is_there = File.file?("#{Lyp::LYP_BIN_DIRECTORY}/lyp")
+      
+      (opts[:no_path_check] || path_is_there) && file_is_there
+    end
+    
+    # Adds ~/.lyp/bin to $PATH to the first profile file that exists, then
+    # returns the profile filename
+    def install!
+      puts "\nInstalling lyp...\n\nAdding ~/.lyp/bin to $PATH..."
+      profile_fn = setup_bin_path
+      puts "Setting up binary scripts..."
+      setup_files
+      
+      if installed?(no_path_check: true)
+        puts "\nTo finish installation, open a new shell or run 'source ~/#{File.basename(profile_fn)}'.\n\n"
+      else
+        raise "Failed to install lyp"
+      end
+    end
+    
+    PROFILE_FILES = %w{
+      .profile .bash_profile .bash_login .bashrc .zshenv .zshrc .mkshrc
+    }.map {|fn| File.join(Dir.home, fn)}
+
+    LYP_LOAD_CODE = <<EOF
+
+[[ ":${PATH}:" == *":${HOME}/.lyp/bin:"* ]] || PATH="$HOME/.lyp/bin:$PATH"
+EOF
+
+    def setup_bin_path
+      fn = PROFILE_FILES.find {|f| File.file?(f)}
+      unless fn
+        raise "Could not find a shell profile file"
+      end
+      
+      unless (IO.read(fn) =~ /\.lyp\/bin/)
+        File.open(fn, 'a') {|f| f << LYP_LOAD_CODE}
+      end
+      fn
+    end
+    
+    def setup_files
+      bin_dir = File.expand_path(File.dirname($0))
+      
+      if is_gem?(bin_dir)
+        setup_gem_files(bin_dir)
+      else
+        setup_release_files(bin_dir)
+      end
+    end
+    
+    RELEASE_BIN_PATH = "lib/app/bin"
+    
+    def is_gem?(bin_dir)
+      bin_dir !~ /#{RELEASE_BIN_PATH}$/
+    end
+    
+    def setup_gem_files(bin_dir)
+
+      FileUtils.rm_rf(Lyp::LYP_BIN_DIRECTORY)
+      FileUtils.mkdir_p(Lyp::LYP_BIN_DIRECTORY)
+
+      %w{lyp lilypond}.each do |fn|
+        FileUtils.ln_sf("#{bin_dir}/#{fn}", "#{Lyp::LYP_BIN_DIRECTORY}/#{fn}")
+      end
+    end
+    
+    def setup_release_files(bin_dir)
+      FileUtils.rm_rf(Lyp::LYP_BIN_DIRECTORY)
+      FileUtils.mkdir_p(Lyp::LYP_BIN_DIRECTORY)
+      
+      release_dir = File.expand_path(File.join(bin_dir, '../../../'))
+      
+      puts "Copying Ruby runtime & gems..."
+      lib_dir = File.join(release_dir, 'lib')
+      FileUtils.rm_rf(Lyp::LYP_LIB_DIRECTORY)
+      FileUtils.cp_r(lib_dir, Lyp::LYP_LIB_DIRECTORY)
+      
+      puts "Copying binary scripts..."
+      wrapper_bin_dir = File.join(release_dir, 'bin')
+      %w{lyp lilypond}.each do |f|
+        FileUtils.cp("#{wrapper_bin_dir}/#{f}", "#{Lyp::LYP_BIN_DIRECTORY}/#{f}")
+      end
+    end
+    
+    def uninstall!
+      puts "\nUninstalling lyp...\n\nRemoving ~/.lyp/bin from $PATH..."
+      
+      # Remove ~/.lyp/bin from $PATH
+      PROFILE_FILES.each do |fn|
+        next unless File.file?(fn)
+        
+        content = IO.read(fn)
+        if (content =~ /\.lyp\/bin/)
+          content.gsub!(/\n?.*\.lyp\/bin.*\n/, '')
+          File.open(fn, 'w+') {|f| f << content}
+        end
+      end
+      
+      puts "Removing binary scripts..."
+      # Delete bin scripts
+      Dir["#{Lyp::LYP_BIN_DIRECTORY}/*"].each do |fn|
+        FileUtils.rm_f(fn) rescue nil
+      end
+      
+      puts "\nTo completely remove installed packages and lilyponds run 'rm -rf ~/.lyp'.\n\n"
+    end
+  end
+end
+

data/lib/lyp/template.rb

@@ -0,0 +1,59 @@
+module Lyp
+  class Template
+    EMIT_DELIMITER = '`'.freeze
+    EMIT_RE = /#{EMIT_DELIMITER}(((?!#{EMIT_DELIMITER}).)*)#{EMIT_DELIMITER}/m
+
+    INTERPOLATION_START = "{{".freeze
+    INTERPOLATION_END = "}}".freeze
+    INTERPOLATION_RE = /#{INTERPOLATION_START}((?:(?!#{INTERPOLATION_END}).)*)#{INTERPOLATION_END}/m
+
+    ESCAPED_QUOTE = '\\"'.freeze
+    QUOTE = '"'.freeze
+  
+    # From the metaid gem
+    def metaclass; class << self; self; end; end
+
+    def initialize(templ)
+      templ = templ.gsub(EMIT_RE) {|m| convert_literal($1)}
+      method_str = <<EOF
+      define_method(:render) do |_ = {}, env = {}|
+        __buffer__ = env[:buffer] ||= ''
+        __emit__ = env[:emit] ||= lambda {|s| __buffer__ << s}
+        __render_l__ = env[:render] ||= lambda {|n, o| Template.render(n, o, env)}
+        metaclass.instance_eval "define_method(:__render__) {|n, o| __render_l__[n, o]}"
+        begin
+          #{templ}
+        end
+        __buffer__
+      end
+EOF
+
+      metaclass.instance_eval method_str
+    end
+  
+    def convert_literal(s)
+      # look for interpolated values, wrap them with #{}
+      s = s.inspect.gsub(INTERPOLATION_RE) do
+        code = $1.gsub(ESCAPED_QUOTE, QUOTE) 
+        "\#{#{code}}"
+      end
+      "__emit__[#{s}]"
+    end
+    
+    # Global template registry
+    @@templates = {}
+
+    def self.load_templates(path)
+      Dir["#{path}/*.rb"].each {|fn| set(File.basename(fn), IO.read(fn))}
+    end
+    
+    def self.set(name, templ)
+      @@templates[name.to_sym] = new(templ)
+    end
+    
+    def self.render(name, arg = {}, env = {})
+      raise unless @@templates[name.to_sym]
+      @@templates[name.to_sym].render(arg, env)
+    end
+  end
+end

data/lib/lyp/templates/deps_wrapper.rb

@@ -0,0 +1,59 @@
+# Expect _ to be a hash of the form:
+# {
+#   user_file: <path>
+#   package_paths: {
+#     <specifier> => <package path>
+#     ...
+#   }
+# }
+
+require 'fileutils'
+
+user_filename = File.expand_path(_[:user_file])
+user_dirname = File.dirname(user_filename)
+
+quote_path = lambda do |path|
+  path = path.gsub("\\", "/") if $WINDOWS
+  path.inspect
+end
+
+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
+# lyp:input-dirname       - the absolute path to the input file directory name
+# lyp:current-package-dir - the directory for the package currently being loaded
+# lyp:package-refs        - a hash table mapping package refs to package entry 
+#                           point absolute paths
+# lyp:package-loaded      - a hash table for keeping track of loaded packages
+# 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:cwd {{quote_path[FileUtils.pwd]}})
+  (define lyp:input-filename {{quote_path[user_filename]}})
+  (define lyp:input-dirname {{quote_path[user_dirname]}})
+  (define lyp:current-package-dir {{quote_path[current_package_dir]}})
+`
+
+_[:package_refs].each do |spec, name|
+`
+  (hash-set! lyp:package-refs "{{spec}}" "{{name}}")`
+end
+
+_[:package_dirs].each do |package, path|
+`
+  (hash-set! lyp:package-dirs "{{package}}" {{quote_path[path]}})`
+end
+
+
+`
+)
+
+#(ly:debug "package loader is ready")
+\include {{quote_path[user_filename]}}
+`

data/lib/lyp/version.rb

@@ -0,0 +1,3 @@
+module Lyp
+  VERSION = "0.2.2"
+end

data/lib/lyp/windows.rb

@@ -0,0 +1,110 @@
+module Process
+  def self.getsid
+    if `tasklist` =~ /^ruby\.exe\s+#{Process.pid}\s+[^\s]+\s+([0-9]+)/
+      $1.to_i
+    else
+      0
+    end
+  end
+end
+
+module Lyp::Lilypond
+  class << self
+    def get_system_lilyponds_paths
+      []
+    end
+  
+    def lyp_lilypond_path(version)
+      "#{Lyp.lilyponds_dir}/#{version}/usr/bin/lilypond.exe"
+    end
+    
+    def lyp_lilypond_share_dir(version)
+      File.join(Lyp.lilyponds_dir, version, 'usr/share')
+    end
+    
+    def lyp_lilyponds
+      list = []
+    
+      Dir["#{Lyp.lilyponds_dir}/*"].each do |path|
+        next unless File.directory?(path) && File.basename(path) =~ /^[\d\.]+$/
+      
+        root_path = path
+        version = File.basename(path)
+        path = File.join(path, "usr/bin/lilypond.exe")
+        list << {
+          root_path: root_path,
+          path: path,
+          version: version
+        }
+      end
+    
+      list
+    end
+  
+    def download_lilypond(url, fn, opts)
+      STDERR.puts "Downloading #{url}" unless opts[:silent]
+
+      if opts[:silent]
+        `curl -s -o "#{fn}" "#{url}"`
+      else
+        `curl -o "#{fn}" "#{url}"`
+      end
+    end
+
+    def uninstall_lilypond_version(path)
+      # run installer
+      uninstaller_path = File.join(path, 'uninstall.exe')
+      if File.file?(uninstaller_path)
+        cmd = "#{uninstaller_path} /S _?=#{path.gsub('/', '\\')}"
+        `#{cmd}`
+      
+        # wait for installer to finish
+        t1 = Time.now
+        while !File.directory?("#{target_dir}/usr")
+          sleep 0.5
+          raise "Uninstallation failed" if Time.now - t1 >= 60
+        end
+      end
+
+      FileUtils.rm_rf(path)
+    end
+  end
+end
+
+module Lyp::Package
+  class << self
+
+    def prepare_local_package_fonts(local_path, package_path)
+      # create fonts directory symlink if needed
+      fonts_path = File.join(local_path, 'fonts')
+      if File.directory?(fonts_path)
+        FileUtils.cp_r(fonts_path, File.join(package_path, 'fonts'))
+      end
+    end
+    
+    def lilypond_fonts_path
+      'usr/share/lilypond/current/fonts'
+    end
+  
+    def lyp_index
+      @lyp_index ||= YAML.load(`curl -s #{LYP_INDEX_URL}`)
+    end
+    
+  end
+end
+
+module Lyp::System
+  class << self
+    def installed?
+      true
+    end
+    
+    def install!
+      puts "\ninstall self curently not supported on Windows.\n\n"
+    end
+    
+    def uninstall!
+      puts "\nuninstall self curently not supported on Windows.\n\n"
+    end
+  end
+end

data/lib/lyp/wrapper.rb

@@ -0,0 +1,22 @@
+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, opts = {})
+    r = Lyp::Resolver.new(fn).resolve_package_dependencies
+
+    # copy current_package_dir option
+    r[:current_package_dir] = opts[:current_package_dir]
+
+    if !r[:package_dirs].empty? || opts[:force_wrap]
+      FileUtils.mkdir_p("#{$TMP_ROOT}/wrappers")
+      fn = "#{$TMP_ROOT}/wrappers/#{File.basename(fn)}" 
+  
+      File.open(fn, 'w+') {|f| f << WRAPPER_TEMPLATE.render(r)}
+    end
+    fn
+  end
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: lyp-win
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- Sharon Rosner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httpclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.7.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.7.1
+- !ruby/object:Gem::Dependency
+  name: ruby-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.5
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.19.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.19.1
+description: Lyp is a tool for managing lilypond versions and lilypond packages
+email: ciconia@gmail.com
+executables:
+- lyp
+- lilypond
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/install_release.sh
+- bin/lilypond
+- bin/lyp
+- bin/release_wrapper_lilypond.sh
+- bin/release_wrapper_lyp.sh
+- lib/lyp.rb
+- 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
+- lib/lyp/resolver.rb
+- lib/lyp/settings.rb
+- lib/lyp/system.rb
+- lib/lyp/template.rb
+- lib/lyp/templates/deps_wrapper.rb
+- lib/lyp/version.rb
+- lib/lyp/windows.rb
+- lib/lyp/wrapper.rb
+homepage: http://github.com/noteflakes/lyp
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Lyp is a package manager for lilypond
+test_files: []