lydown 0.10.0 → 0.12.4

data/bin/lydown

@@ -2,4 +2,8 @@
 
 require 'lydown/cli'
 
-Lydown::CLI::Commands.start(ARGV)
+if ARGV.empty?
+  Lydown::CLI::REPL.run
+else
+  Lydown::CLI::Commands.start(ARGV)
+end

data/lib/lydown/cache.rb

@@ -1,5 +1,4 @@
 require 'digest/md5'
-require 'msgpack'
 
 module Cache
   class << self
@@ -26,7 +25,7 @@ module Cache
     
     def calculate_hash(*params)
       params.map do |p|
-        Digest::MD5.hexdigest(p.is_a?(String) ? p : p.to_msgpack)
+        Digest::MD5.hexdigest(p.is_a?(String) ? p : p.to_s)
       end.join('-')
     end
       

data/lib/lydown/cli.rb

@@ -9,5 +9,7 @@ require 'lydown/cli/proofing'
 require 'lydown/cli/diff'
 require 'lydown/cli/translation'
 require 'lydown/cli/output'
+require 'lydown/cli/repl'
+require 'lydown/cli/installer'
 require 'lydown/cli/commands'
 require 'lydown/cli/signals'

data/lib/lydown/cli/commands.rb

@@ -5,15 +5,19 @@ module Lydown::CLI
     desc "version", "show Lydown version"
     def version
       require 'lydown/version'
+      $stderr.puts "Lydown version #{Lydown::VERSION}"
       
-      puts "Lydown version #{Lydown::VERSION}"
-      exit!(0)
+      lilypond_version = Lydown::CLI::Support.detect_lilypond_version(false)
+      if lilypond_version
+        $stderr.puts "Lilypond version #{lilypond_version}"
+      end
     end
-
+    
     desc "compile [PATH]", "compile the lydown source at PATH"
     method_option :format, aliases: '-f', 
       default: 'pdf', desc: 'Set output format (pdf/png/ly/midi/mp3)', 
       enum: %w{pdf png ly midi mp3}
+    method_option :pdf, type: :boolean, desc: 'Set PDF output format'
     method_option :png, type: :boolean, desc: 'Set PNG output format'
     method_option :ly, type: :boolean, desc: 'Set Lilypond output format'
     method_option :midi, type: :boolean, desc: 'Set MIDI output format'
@@ -35,14 +39,23 @@ module Lydown::CLI
       desc: 'Create separate file for each movement'
     method_option :verbose, type: :boolean
     def compile(*args)
+      path = args.first || '.'
+
+      # check if user specified a command as an argument (e.g. --version)
+      if (path =~ /^\-\-(\w+)/) && respond_to?($1)
+        return send($1)
+      end
+      
+      Lydown::CLI::Support.detect_lilypond_version(true)
+      
       require 'lydown'
       
       opts = Lydown::CLI::Support.copy_options(options)
-      opts[:path] = args.first || '.'
+      opts[:path] = path
       
       # Set format based on direct flag
       opts[:format] = opts[:format].to_sym if opts[:format]
-      [:png, :ly, :midi, :mp3].each {|f| opts[:format] = f if opts[f]}
+      [:pdf, :png, :ly, :midi, :mp3].each {|f| opts[:format] = f if opts[f]}
 
       opts[:parts] = opts[:parts].split(',') if opts[:parts]
       opts[:movements] = opts[:movements].split(',') if opts[:movements]
@@ -51,8 +64,6 @@ module Lydown::CLI
       Lydown::CLI::Support.detect_work_directory(opts)
       Lydown::CLI::Support.detect_filename(opts)
       
-      p opts
-
       if (opts[:format] == :midi) || (opts[:format] == :mp3)
         opts[:score_only] = true
         opts[:parts_only] = false
@@ -77,6 +88,8 @@ module Lydown::CLI
       enum: %w{pdf png ly}
     method_option :include_parts, aliases: '-i', desc: 'Include parts (comma separated)'
     def proof(*args)
+      Lydown::CLI::Support.detect_lilypond_version(true)
+
       require 'lydown'
 
       opts = Lydown::CLI::Support.copy_options(options)
@@ -102,6 +115,11 @@ module Lydown::CLI
       Lydown::CLI::Translation.process(opts)
     end
     
+    desc "install [PACKAGE] [VERSION]", "install a package"
+    def install(*args)
+      Lydown::CLI::Installer.install(*args)
+    end
+    
     def method_missing(method, *args)
       args = ["compile", method.to_s] + args
       self.class.start(args)

data/lib/lydown/cli/compiler.rb

@@ -18,16 +18,26 @@ module Lydown::CLI::Compiler
     }
     
     def process(opts)
-      t1 = Time.now
+      @start_time = Time.now
 
       opts = opts.deep_clone
       work = create_work_from_opts(opts)
       
       jobs = create_jobs_from_opts(work, opts)
+      
+      # check if no jobs were created. This could happen when lydown processes
+      # parts but no parts are found
+      if jobs[:compile].empty?
+        $stderr.puts "No parts found."
+        return
+      end
+      
       process_jobs(work, jobs, opts)
       
-      t2 = Time.now
-      $stderr.puts "Elapsed: #{'%.1f' % [t2-t1]}s"
+      now = Time.now
+      unless opts[:silent] || opts[:format] == :midi
+        $stderr.puts "Elapsed: #{'%.1f' % [now - @start_time]}s"
+      end
     end
     
     def create_jobs_from_opts(work, opts)
@@ -212,7 +222,7 @@ module Lydown::CLI::Compiler
     end
     
     def open_target(opts)
-      filename = "#{opts[:output_target]}.#{opts[:format]}"
+      filename = "#{opts[:output_target]}.#{opts[:format] || 'pdf'}"
       
       unless File.file?(filename)
         filename2 = "#{opts[:output_target]}-page1.#{opts[:format]}"
@@ -224,18 +234,31 @@ module Lydown::CLI::Compiler
       end
       
       if opts[:format] == :midi
-        open_midi_target(filename)
+        open_midi_target(filename, opts)
       else
         system("open #{filename}")
       end
     end
     
-    def open_midi_target(filename)
+    def open_midi_target(filename, opts)
+      now = Time.now
+      unless opts[:silent]
+        $stderr.puts "Elapsed: #{'%.1f' % [now - @start_time]}s"
+      end
+
       $stderr << "Playing #{filename}..."
       Open3.popen2e("timidity #{filename}") do |input, output, wait_thr|
-        input.close
-        output.read
-        output.close
+        begin
+          prev_handler = trap("INT") do
+            Process.kill("INT", wait_thr.pid)
+            prev_handler.call if prev_handler
+          end
+          input.close
+          output.read
+          output.close
+        ensure
+          trap("INT", prev_handler)
+        end
       end
     end
   end

data/lib/lydown/cli/diff.rb

@@ -18,7 +18,7 @@ module Lydown::CLI::Diff
         set_cached_content(path, read_content(path)) rescue nil
         count += 1
       end
-      $stderr.puts "Cached #{count} files."
+      # $stderr.puts "Cached #{count} files."
     end
     
     def read_content(path)

data/lib/lydown/cli/installer.rb

@@ -0,0 +1,175 @@
+require 'net/http'
+require 'uri'
+require 'ruby-progressbar'
+require 'tempfile'
+require 'fileutils'
+
+module Lydown::CLI::Installer
+  class << self
+    def install(package, version = nil)
+      case package
+      when 'lilypond'
+        Lilypond.install(version)
+      else
+        STDERR.puts "Unknown package name specified"
+        exit!(1)
+      end
+    end
+  end
+  
+  module Lilypond
+    class << self
+      LILYPOND_DEFAULT_VERSION = "2.19.29"
+      
+      def detect_version(specified_version)
+        case specified_version
+        when nil, 'stable'
+          list = get_version_list
+        end
+      end
+    
+      def install(version = nil)
+        platform = detect_lilypond_platform
+        version ||= LILYPOND_DEFAULT_VERSION
+        # version = detect_version(version)
+        url = lilypond_install_url(platform, version)
+        fn = Tempfile.new('lydown-lilypond-installer').path
+
+        download_lilypond(url, fn)
+        install_lilypond_files(fn, platform, version)
+      rescue => e
+        STDERR.puts "Failed to install lilypond #{version}"
+        puts e.message
+        puts e.backtrace.join("\n")
+        exit(1)
+      end
+    
+      BASE_URL = "http://download.linuxaudio.org/lilypond/binaries"
+    
+      def lilypond_install_url(platform, version)
+        ext = platform =~ /darwin/ ? ".tar.bz2" : ".sh"
+        filename = "lilypond-#{version}-1.#{platform}"
+      
+        "#{BASE_URL}/#{platform}/#{filename}#{ext}"
+      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 download_lilypond(url, fn)
+        STDERR.puts "Downloading #{url}"
+      
+        url_base = url.split('/')[2]
+        url_path = '/'+url.split('/')[3..-1].join('/')
+        download_count = 0
+
+        Net::HTTP.start(url_base) do |http|
+          request_url = URI.escape(url_path)
+          response = http.request_head(request_url)
+          total_size = response['content-length'].to_i
+          pbar = ProgressBar.create(title: 'Downloading', total: total_size)
+          File.open(fn, 'w') do |f|
+            http.get(request_url) do |data|
+              f << data
+              download_count += data.length 
+              pbar.progress = download_count if download_count <= total_size
+            end
+          end
+          pbar.finish
+        end
+      end
+    
+      def install_lilypond_files(fn, platform, version)
+        case platform
+        when /darwin/
+          install_lilypond_files_osx(fn, version)
+        when /linux/
+          install_lilypond_files_linux(fn, version)
+        end
+      end
+    
+      def install_lilypond_files_osx(fn, version)
+        target = "/tmp/lydown/installer/lilypond"
+        FileUtils.mkdir_p(target)
+      
+        STDERR.puts "Extracting..."
+        exec "tar -xjf #{fn} -C #{target}"
+      
+        copy_lilypond_files("#{target}/LilyPond.app/Contents/Resources", version)
+      end
+    
+      def install_lilypond_files_linux(fn, version)
+        target = "/tmp/lydown/installer/lilypond"
+        FileUtils.mkdir_p(target)
+      
+        # create temp directory in which to untar file
+        tmp_dir = "/tmp/lydown/#{Time.now.to_f}"
+        FileUtils.mkdir_p(tmp_dir)
+      
+        FileUtils.cd(tmp_dir) do
+          exec "sh #{fn} --tarball"
+        end
+      
+        STDERR.puts "Extracting..."
+        exec "tar -xjf #{tmp_dir}/#{fn} -C #{target}"
+      
+        copy_lilypond_files_linux("#{target}/usr", version)
+      end
+
+      def copy_lilypond_files(base_path, version)
+        target_dir = File.expand_path("~/.lydown/packages/lilypond/#{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..."
+        %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
+        
+        install_lilypond_executable(base_path, version)
+      end
+      
+      BIN_SCRIPT_PATH = "#{File.expand_path('~')}/bin/lilypond"
+      
+      def install_lilypond_executable(base_path, version)
+        target_dir = File.expand_path("~/.lydown/packages/lilypond/#{version}")
+
+        script = "#!/bin/sh\n#{target_dir}/bin/lilypond \"$@\"\n"
+        
+        # create executable
+        FileUtils.rm(BIN_SCRIPT_PATH) if File.file?(BIN_SCRIPT_PATH)
+        File.open(BIN_SCRIPT_PATH, 'w+') {|f| f << script}
+        FileUtils.chmod('+x', BIN_SCRIPT_PATH)
+        # symlink_path = File.expand_path('~/bin/lilypond')
+        # FileUtils.ln_sf("#{target_dir}/bin/lilypond", symlink_path)
+        
+        test_lilypond
+      end
+      
+      def test_lilypond
+        STDERR.puts `lilypond -v`
+      end
+      
+      def exec(cmd)
+        raise unless system(cmd)
+      end
+    end
+  end
+end

data/lib/lydown/cli/proofing.rb

@@ -3,55 +3,55 @@ require 'directory_watcher'
 module Lydown::CLI::Proofing
   class << self
     def start_proofing(opts)
-      source = opts[:source_filename]
-      
-      Lydown::CLI::Diff.fill_cache(source)
-      
       $stderr.puts "Proof mode: #{source} -> #{opts[:output_filename]}"
-      last_proof_path = nil
 
-      watch_directory(source, opts)
-    end
-    
-    def watch_directory(source, opts)
-      dw = DirectoryWatcher.new(
-        File.expand_path(source),
-        glob: ["**/*.ld"],
-        pre_load: true
-      )
-      dw.interval = 0.25
-
-      dw.add_observer do |*args|
-        args.each do |e|
-          if e.type == :modified
-            path = File.expand_path(e.path)
-            if path =~ /^#{File.expand_path(source)}\/(.+)/
-              path = $1
-            end
-            last_proof_path = e.path unless File.basename(e.path) == 'movement.ld'
-            if last_proof_path
-              file_opts = opts.deep_merge opts_for_path(last_proof_path, opts)
-              file_opts[:base_path] = path
-              process(file_opts)
-            end
-          end
-        end
-      end
-       
       trap("INT") {return}
-      dw.start
+      watch(opts)
       loop {sleep 1000}
     ensure
-      dw.stop
+      unwatch
     end
     
-    def globs(path)
-      Dir.chdir(path) do
-        dirs = Dir['*'].select { |x| File.directory?(x) }
+    def watch(opts)
+      unwatch # teardown previous watcher
+      
+      source = opts[:source_filename]
+      Lydown::CLI::Diff.fill_cache(source)
+      @last_proof_path = nil
+      
+      @watcher = DirectoryWatcher.new(source, glob: ["**/*.ld"], pre_load: true)
+      
+      @watcher.interval = 0.25
+      @watcher.add_observer do |*events|
+        events.each do |e|
+          handle_changed_file(e, opts) if e.type == :modified
+        end
       end
+      @watcher.start
+    end
     
-      dirs = dirs.map { |x| "#{x}/**/*" }
-      dirs
+    def unwatch
+      return unless @watcher
+
+      @watcher.stop
+      @watcher = nil
+    end
+    
+    def handle_changed_file(event, opts)
+      path = File.expand_path(event.path)
+      if path =~ /^#{opts[:source_filename]}\/(.+)/
+        path = $1
+      end
+      @last_proof_path = event.path unless File.basename(event.path) == 'movement.ld'
+      if @last_proof_path
+        file_opts = opts.deep_merge(opts_for_path(@last_proof_path, opts))
+        file_opts[:base_path] = path
+        process(file_opts)
+      end
+    rescue => e
+      puts e.class
+      puts e.message
+      puts e.backtrace.join("\n")
     end
     
     def opts_for_path(path, opts)
@@ -87,7 +87,10 @@ module Lydown::CLI::Proofing
     def process(opts)
       if opts[:line_range] != [nil, nil]
         t = Time.now.strftime("%H:%M:%S")
-        $stderr.puts "[#{t}] Changed: #{opts[:base_path]} (lines #{opts[:line_range][0]}..#{opts[:line_range][1]})"
+        unless opts[:silent]
+          $stderr.puts "[#{t}] Changed: #{opts[:base_path]} \
+            (lines #{opts[:line_range][0]}..#{opts[:line_range][1]})"
+        end
         Lydown::CLI::Compiler.process(opts)
       end
     end