lydown 0.10.0 → 0.12.4

data/lib/lydown/cli/repl.rb

@@ -0,0 +1,232 @@
+#encoding: utf-8
+
+require 'fileutils'
+require 'readline'
+
+module Lydown::CLI::REPL
+  class << self
+    def run
+      require 'lydown/version'
+      puts "Lydown version #{Lydown::VERSION}"
+      
+      lilypond_version = Lydown::CLI::Support.detect_lilypond_version(true)
+      if lilypond_version
+        puts "Lilypond version #{lilypond_version}"
+      end
+
+      require 'lydown'
+      
+      orig_dir = FileUtils.pwd
+      
+      trap("INT") do
+        Lydown::CLI::Proofing.unwatch # stop file watcher for proofing
+        save_history
+        puts
+        FileUtils.cd(orig_dir)
+        exit(0)
+      end
+      
+      load_history
+      
+      update_proofing_watcher(orig_dir)
+      
+      while line = Readline.readline(prompt, true).chomp
+        maintain_clean_history(line)
+        process(line)
+      end
+    end
+    
+    def maintain_clean_history(line)
+      if line =~ /^\s*$/ or Readline::HISTORY.to_a[-2] == line
+        Readline::HISTORY.pop
+      end
+    end
+    
+    HISTORY_FN = File.expand_path('~/.lydown_history')
+    
+    def load_history
+      IO.read(HISTORY_FN).lines.each do |l|
+        Readline::HISTORY << l.chomp
+      end
+    rescue
+    end
+    
+    def save_history
+      File.open(HISTORY_FN, 'w+') do |f|
+        Readline::HISTORY.to_a.each do |l|
+          f.puts l
+        end
+      end
+    rescue => e
+      puts "Failed to save history: #{e.message}"
+    end
+    
+    def prompt
+      "#{File.basename(FileUtils.pwd)}♫ "
+    end
+    
+    def process(line)
+      if line =~ /^([a-z]+)\s?(.*)$/
+        cmd = $1
+        args = $2
+        cmd_method = :"handle_#{cmd}"
+        if respond_to?(cmd_method)
+          send(cmd_method, args)
+        else
+          handle_default(line)
+        end
+      end
+    end
+    
+    HELP = <<EOF
+    
+    pwd                 Print working directory
+    cd <path>           Change working directory
+    ls [<path>]         Show lydown files in working directory
+
+    cat <file>          Show content of file
+    cat <file>:<line>   Show content of file at specified line, or range of
+                        lines, e.g. cat flute1:13, or cat flute1:25-27
+
+    edit <file>         Edit file using vim
+    edit <file>:<line>  Edit file using vim, place cursor at specified line
+    
+    score               Compile & open score
+    midi                Compile & open MIDI file
+    <part>              Compile & open part
+    
+    To exit press ctrl-C
+EOF
+    
+    def handle_help(args)
+      puts HELP; puts
+    end
+    
+    def handle_pwd(args)
+      puts FileUtils.pwd
+    end
+    
+    def handle_cd(args)
+      path = File.expand_path(args)
+      FileUtils.cd(path)
+      update_proofing_watcher(path)
+    rescue => e
+      puts e.message
+    end
+    
+    def handle_git(args)
+      puts `git #{args}`
+    end
+    
+    def handle_edit(args)
+      if args =~ /(.*):(\d+)$/
+        fn = $1; line = $2
+      else
+        fn = args; line = nil
+      end
+      
+      return unless fn = validate_filename(fn)
+
+      if line
+        system "vim +#{line} #{fn} -c 'normal zz'"
+      else
+        system "vim #{fn}"
+      end
+    end
+    
+    def validate_filename(fn)
+      unless File.file?(fn)
+        fn += '.ld'
+        unless File.file?(fn)
+          puts "File not found"
+          return nil
+        end
+      end
+      fn
+    end
+    
+    def update_proofing_watcher(path)
+      opts = {path: path, proof_mode: true, open_target: true, 
+        no_progress_bar: true, silent: true, repl: true}
+      Lydown::CLI::Support.detect_work_directory(opts)
+      Lydown::CLI::Support.detect_filename(opts)
+      
+      Lydown::CLI::Proofing.watch(opts)
+    end
+    
+    def handle_ls(args)
+      system 'ls'
+    end
+    
+    def handle_cat(args)
+      if args =~ /^([^\s:]+):?(\d+)?\-?(\d+)?$/
+        fn = $1
+        line_start = $2
+        line_end = $3
+        
+        if line_start
+          if line_end
+            line_range = (line_start.to_i - 1)..(line_end.to_i - 1)
+          else
+            line_range = (line_start.to_i - 1)..(line_start.to_i - 1)
+          end
+        else
+          line_range = nil
+        end
+          
+        return unless fn = validate_filename(fn)
+        
+        content = IO.read(fn)
+        unless line_range
+          puts content
+        else
+          puts content.lines[line_range].join
+        end
+      end
+    end
+    
+    def handle_score(args)
+      opts = {path: '.', open_target: true, mode: :score, repl: true}
+      $stderr.puts "Processing score..."
+      compile(opts)
+    end
+    
+    def handle_midi(args)
+      opts = {path: '.', open_target: true, mode: :score, format: :midi, 
+        repl: true
+      }
+      $stderr.puts "Processing MIDI..."
+      compile(opts)
+    end
+    
+    def handle_default(args)
+      opts = {}
+      
+      args.split(',').map(&:strip).each do |a|
+        if File.file?(a) || File.file?("#{a}.ld")
+          opts = {path: '.', parts: [a], mode: :part, open_target: true, repl: true}
+        elsif File.directory?(a)
+          opts = {path: '.', movements: [a], mode: :score, open_target: true, repl: true}
+        else
+          raise LydownError, "Invalid path specified - #{a}"
+        end
+        $stderr.puts "Processing #{a}..."
+        compile(opts)
+      end
+    rescue => e
+      # do nothing
+    end
+    
+    def compile(opts)
+      Lydown::CLI::Support.detect_work_directory(opts)
+      Lydown::CLI::Support.detect_filename(opts)
+
+      prev_handler = trap("INT") do
+        puts
+      end
+      Lydown::CLI::Compiler.process(opts)
+    ensure
+      trap("INT", prev_handler)
+    end
+  end
+end

data/lib/lydown/cli/support.rb

@@ -49,6 +49,39 @@ module Lydown::CLI::Support
       opts[:path] = parent_dir
     end
   end
+  
+  MINIMAL_LILYPOND_VERSION = Gem::Version.new('2.18')
+  
+  # detect the lilypond version. If lilypond is not found, or the version is
+  # less than the minimal supported version, display an error message.
+  def self.detect_lilypond_version(exit_on_error)
+    msg = `lilypond --version`
+    version = nil
+    if msg.lines.first =~ /LilyPond ([\d\.]+)/
+      version = $1
+    end
+    unless version && Gem::Version.new(version) >= MINIMAL_LILYPOND_VERSION
+      display_lilypond_version_error_msg(version)
+      exit!(1) if exit_on_error
+      version = nil
+    end
+    version
+  rescue => e
+    display_lilypond_version_error_msg(nil)
+    exit!(1) if exit_on_error
+  end
+  
+  def self.display_lilypond_version_error_msg(version)
+    if version
+      STDERR.puts "ERROR: The installed lilypond (version #{version}) is too old.
+       You can install lilypond by running `lydown install lilypond` or by
+       downloading a recent version from http://lilypond.org/"
+    else
+      STDERR.puts "ERROR: No copy of lilypond found.
+       You can install lilypond by running `lydown install lilypond` or by
+       downloading a recent version from http://lilypond.org/"
+    end
+  end
 end
 
 

data/lib/lydown/core_ext.rb

@@ -213,3 +213,11 @@ class Pathname
     self.new(path).relative_path_from(pwd).to_s
   end
 end
+
+unless Binding.method_defined?(:local_variable_set)
+  class Binding
+    def local_variable_set(var, value)
+      eval("#{var.to_s} = #{value.inspect}")
+    end
+  end
+end

data/lib/lydown/lilypond.rb

@@ -138,6 +138,7 @@ module Lydown
                 bar.progress = idx + 1 if idx
               end
             end
+            bar.progress = STATUS_TOTAL
           end
         else
           info = f.read

data/lib/lydown/ly_lib/lib.ly

@@ -85,7 +85,7 @@ ficta = {
         
 
 \layout {
-  #(layout-set-staff-size 14)
+  #(layout-set-staff-size 17)
   indent = 0\cm
 
   \context {

data/lib/lydown/parsing.rb

@@ -6,7 +6,7 @@ require 'lydown/parsing/lydown.treetop'
 
 class LydownParser
   def self.parse(source, opts = {})
-    if opts[:no_progress]
+    if opts[:no_progress_bar]
       do_parse(source, opts)
     else
       Lydown::CLI.show_progress('Parse', source.length * 2) do |bar|

data/lib/lydown/rendering.rb

@@ -63,6 +63,40 @@ module Lydown::Rendering
       
       "\"#{varname}\""
     end
+    
+    def add_includes(filenames, context, key, opts)
+      includes = context.get_setting(key, opts)
+      filenames.concat(includes) if includes
+    end
+    
+    def include_files(context, opts)
+      filenames = []
+      if opts.has_key?(:movement)
+        add_includes(filenames, context, :includes, opts)
+        case context.render_mode
+        when :score
+          add_includes(filenames, context, 'score/includes', opts)
+        when :part
+          add_includes(filenames, context, 'parts/includes', opts)
+          if opts[:part]
+            add_includes(filenames, context, "parts/#{opts[:part]}/includes", opts)
+          end
+        end
+      else
+        # paths to be included at top of lilypond doc should be defined under
+        # document/includes
+        add_includes(filenames, context, 'document/includes', opts)
+      end
+      
+      filenames.map do |fn|
+        case File.extname(fn)
+        when '.ely'
+          Lydown::Templates.render(fn, context)
+        else
+          "\\include \"#{fn}\""
+        end
+      end
+    end
   end
 end
 

data/lib/lydown/rendering/base.rb

@@ -10,7 +10,7 @@ module Lydown::Rendering
     def translate
       # do nothing by default
     end
-
+    
     def next_event
       idx = @idx + 1
       while idx < @stream.size

data/lib/lydown/rendering/movement.rb

@@ -43,17 +43,6 @@ module Lydown::Rendering
       PAGE_BREAKS[setting] || {}
     end
     
-    def self.include_files(context, opts)
-      (context.get_setting(:includes, opts) || []).map do |fn|
-        case File.extname(fn)
-        when '.ely'
-          Lydown::Templates.render(fn, context)
-        else
-          "\\include \"#{fn}\""
-        end
-      end
-    end
-    
     # Groups movements by bookparts. Whenever a movement requires a page break
     # before, a new group is created
     def self.bookparts(context, opts)

data/lib/lydown/rendering/music.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'lydown/rendering/figures'
 require 'lydown/rendering/notes'
 

data/lib/lydown/rendering/notes.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'lydown/rendering/figures'
 
 module Lydown::Rendering

data/lib/lydown/rendering/settings.rb

@@ -1,3 +1,8 @@
+# encoding: utf-8
+
+require 'fileutils'
+require 'pathname'
+
 module Lydown::Rendering
   class Setting < Base
     include Notes
@@ -7,7 +12,7 @@ module Lydown::Rendering
       'accidentals', 'beams', 'end_barline', 'macros', 'empty_staves',
       'midi_tempo', 'instrument_names', 'instrument_name_style',
       'parts', 'score', 'movement_source', 'colla_parte', 'include',
-      'mode', 'nomode', 'bar_numbers'
+      'mode', 'nomode', 'bar_numbers', 'document', 'notation_size'
     ]
 
     RENDERABLE_SETTING_KEYS = [
@@ -22,7 +27,8 @@ module Lydown::Rendering
       'instrument_name_style' => ['normal', 'smallcaps'],
       'page_break' => ['none', 'before', 'after', 'before and after', 'blank page before'],
       'mode' => ['score', 'part', 'none'],
-      'bar_numbers' => ['hide', 'shows']
+      'bar_numbers' => ['hide', 'shows'],
+      'notation_size' => ['huge', 'large', 'normalsize', 'small', 'tiny', 'teeny']
     }
 
     def translate
@@ -60,10 +66,7 @@ module Lydown::Rendering
           @context[:movement] = value
           @context.reset(:movement)
         when 'include'
-          includes = @context.get_current_setting(:includes) 
-          includes ||= []
-          includes << value
-          @context.set_setting(:includes, includes)
+          add_include(:includes, value)
         when 'mode'
           set_mode(value.nil? ? :none : value.to_sym)
         when 'nomode'
@@ -81,8 +84,13 @@ module Lydown::Rendering
         while l < level
           path << "#{@context['process/setting_levels'][l]}/"; l += 1
         end
-        path << key
-        @context.set_setting(path, value)
+        case key
+        when 'include'
+          add_include(path + 'includes', value)
+        else
+          path << key
+          @context.set_setting(path, value)
+        end
       end
 
       @context['process/setting_levels'] ||= {}
@@ -154,6 +162,24 @@ module Lydown::Rendering
     def set_mode(mode)
       @context['process/mode'] = (mode == :none) ? nil : mode
     end
+    
+    def add_include(includes_path, path)
+      includes = @context.get_current_setting(includes_path) || []
+
+      source_filename = @context['process/last_filename']
+      if source_filename
+        absolute_path = File.expand_path(
+          File.join(File.dirname(source_filename), path)
+        )
+        # calculate relative path to working directory
+        pwd = Pathname.new(FileUtils.pwd)
+        includes << Pathname.new(absolute_path).relative_path_from(pwd).to_s
+      else
+        includes << path
+      end
+
+      @context.set_setting(includes_path, includes)
+    end
   end
 end