lydown 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d8be82e654bd57692d8e882f1c8643bd684d637c
-  data.tar.gz: 80c45eb4a1a4c4eb26960356e01774150d0b2697
+  metadata.gz: 8f9e00d9938576429da9646dc782f2451c66afa9
+  data.tar.gz: 3fe22010c7e1928c74a5278eb659dc78922a53a8
 SHA512:
-  metadata.gz: 755759c7dbc352e537743f8b829f35791297baa586a89a2e80cbd6fd98aef6a48cd54bb8f2d7c26c1aa8a4568701c69d5fdf117d56a271e9a1aebdf24aecbf0c
-  data.tar.gz: e5e151f5f78d6b372ca5cf655aeba53dc68be083d6b34b160b0211c89a9c6765498db2878f093ebd7d3e1c9fdac9d3bd2da11ee955c43b768b944f72e81d9f8f
+  metadata.gz: f18283718262a5404cb6e78ba0c155c3c0f750eaf3ddf47b3f5e6b460836980fb9019e2146bb093aa662e1da25625880fb935479e9766a47f565dd4107300516
+  data.tar.gz: 86b12d5d519691dc54f18fcfd061eb2d26a1d403780b3e8b5d800e32278bb78250841c818f1a76d7353fd5deffc99642d2eecf960c756205b06c7389a2e72650

data/bin/lydown

@@ -13,7 +13,7 @@ help = <<HELP
 Lydown is not lilypond
 HELP
 
-$options = {'format' => 'pdf'}
+$options = {'format' => 'pdf'}.deep!
 opts = OptionParser.new do |opts|
   opts.banner = help
 
@@ -23,64 +23,64 @@ opts = OptionParser.new do |opts|
   end
   
   opts.on("-p", "--parts PART", "Parts (comma-separated)") do |v|
-    $options["parts"] = v.split(',')
+    $options[:parts] = v.split(',')
   end
   
   opts.on("-m", "--mvts MVT", "Movements (comma-separated)") do |v|
-    $options["movements"] = v.split(',')
+    $options[:movements] = v.split(',')
   end
   
   opts.on("--no-score", "Do not generate secore") do
-    $options["no_score"] = true
+    $options[:no_score] = true
   end
   
   opts.on("-s", "--score", "Generate only score, no parts") do
-    $options["score_only"] = true
+    $options[:score_only] = true
   end
   
   opts.on("-V", "--vocal", "Generate only vocal score") do
-    $options["vocal_only"] = true
+    $options[:vocal_only] = true
   end
   
   opts.on("--ly", "Generate Lilypond file") do
-    $options["format"] = 'ly'
+    $options[:format] = 'ly'
   end
   
   opts.on("--pdf", "Generate PDF file") do
-    $options["format"] = 'pdf'
+    $options[:format] = 'pdf'
   end
 
   opts.on("--png", "Generate PNG file") do
-    $options["format"] = 'png'
+    $options[:format] = 'png'
   end
 
   opts.on("-M", "--midi", "Generate midi file") do
-    $options["format"] = 'midi'
-    $options["score_only"] = true # implied
+    $options[:format] = 'midi'
+    $options[:score_only] = true # implied
   end
   
   opts.on("-P", "--proof", "Start proofing mode") do
-    $options["proof_mode"] = true
+    $options[:open_target] = true
+    $options[:proof_mode] = true
   end
   
   opts.on("-O", "--open", "Open PDF/Midi file after processing") do
-    $options["open_target"] = true
+    $options[:open_target] = true
   end
 
   opts.on("-o", "--output FILE", "Filename for output") do |v|
-    $options["output_filename"] = v
+    $options[:output_filename] = v
   end
 
   opts.on("-W", "--work", "Create new work") do
-    $options["gen"] = :work
+    $options[:gen] = :work
   end
 end
 
 opts.parse!
-$options.deep!
 
-if $options["gen"]
-  # Ripple.generate($options["gen"], ARGV)
+if $options[:gen]
+  # Ripple.generate($options[:gen], ARGV)
   exit
 end
 
@@ -91,26 +91,36 @@ if ARGV[0] == '-'
   
   # the output defaults to a file named lydown expect if the format is ly.
   # In that case the output will be sent to STDOUT.
-  $options["output_filename"] ||= 'lydown' unless $options["format"] == 'ly'
+  $options[:output_filename] ||= 'lydown' unless $options[:format] == 'ly'
 else
   filename = ARGV[0] || '.'
-  $options['source_filename'] = filename
+  $options[:source_filename] = filename
   if (filename !~ /\.ld$/) and File.file?(filename + ".ld")
     filename += ".ld"
   end
   
-  $options["output_filename"] ||= (filename =~ /^(.+)\.ld$/) ? $1 : filename
-end
-
-# compile score
-unless $options[:no_score] || $options[:parts]
-  Lydown::CLI::Compiler.process($options.merge(mode: :score, parts: nil))
+  unless $options[:output_filename]
+    if filename == '.'
+      $options[:output_filename] = File.basename(FileUtils.pwd)
+    else
+      $options[:output_filename] = (filename =~ /^(.+)\.ld$/) ? $1 : filename
+    end
+  end
 end
 
-# compile parts
-unless $options[:score_only] || !$options[:parts]
-  parts = $options[:parts]
-  parts.each do |p|
-    Lydown::CLI::Compiler.process($options.merge(mode: :part, parts: p))
+if $options[:proof_mode]
+  Lydown::CLI::Proofing.start_proofing($options)
+else
+  # compile score
+  unless $options[:no_score] || $options[:parts]
+    Lydown::CLI::Compiler.process($options.merge(mode: :score, parts: nil))
   end
-end
+
+  # compile parts
+  unless $options[:score_only] || !$options[:parts]
+    parts = $options[:parts]
+    parts.each do |p|
+      Lydown::CLI::Compiler.process($options.merge(mode: :part, parts: p))
+    end
+  end
+end

data/lib/lydown/cli/compiler.rb

@@ -68,6 +68,11 @@ module Lydown::CLI::Compiler
 
       if opts[:open_target]
         filename = "#{opts[:output_target]}.#{opts[:format]}"
+        
+        unless File.file?(filename)
+          filename = "#{opts[:output_target]}-page1.#{opts[:format]}"
+        end
+        
         system("open #{filename}")
       end
     end

data/lib/lydown/cli/diff.rb

@@ -0,0 +1,52 @@
+require 'diff/lcs'
+
+module Lydown::CLI::Diff
+  class << self
+    CACHE = {}
+    
+    def cached_content(path)
+      CACHE[File.absolute_path(path)] || []
+    end
+    
+    def set_cached_content(path, content)
+      CACHE[File.absolute_path(path)] = content
+    end
+    
+    def fill_cache(dir)
+      count = 0
+      Dir["#{dir}/**/*.ld"].each do |path|
+        set_cached_content(path, read_content(path)) rescue nil
+        count += 1
+      end
+      puts "Cached #{count} files."
+    end
+    
+    def read_content(path)
+      IO.read(path).lines.map {|l| l.chomp}
+    end
+    
+    def diff_line_range(path)
+      new_version = read_content(path)
+      old_version = cached_content(path)
+      
+      first = nil
+      last = nil
+      
+      diffs = Diff::LCS.diff(old_version, new_version).each do |d|
+        d.each do |r|
+          line = r.to_a[1]
+          first = line if first.nil? || line < first
+          last = line if last.nil? || line > last
+        end
+      end
+      
+      set_cached_content(path, new_version)
+      
+      first..last
+    rescue => e
+      STDERR << e.message
+      STDERR << e.backtrace.join("\n")
+      nil..nil
+    end
+  end
+end

data/lib/lydown/cli/proofing.rb

@@ -0,0 +1,97 @@
+require 'directory_watcher'
+
+module Lydown::CLI::Proofing
+  class << self
+    def start_proofing(opts)
+      source = opts[:source_filename]
+      
+      Lydown::CLI::Diff.fill_cache(source)
+      
+      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))
+      dw.interval = 0.25
+      dw.glob = ["#{source}/**/*.ld"]
+
+      dw.reset(true)
+      dw.add_observer do |*args|
+        t = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+        args.each do |e|
+          if e.type = :modified
+            path = File.expand_path(e.path)
+            if path =~ /^#{File.expand_path(source)}\/(.+)/
+              path = $1
+            end
+            puts "[#{t}] Changed: #{path}"
+            last_proof_path = e.path unless File.basename(e.path) == 'movement.ld'
+            process(opts.deep_merge opts_for_path(last_proof_path, opts)) if last_proof_path
+          end
+        end
+      end
+       
+      trap("INT") {return}
+      dw.start
+      loop {sleep 1000}
+    ensure
+      dw.stop
+    end
+    
+    def globs(path)
+      Dir.chdir(path) do
+        dirs = Dir['*'].select { |x| File.directory?(x) }
+        # exclude _ly, _pdf, _midi dirs
+        # ['ly_dir', 'pdf_dir', 'midi_dir'].map {|d| $config[d]}.each do |d|
+        #   if d =~ /^\.\/(.*)/
+        #     dirs -= [$1]
+        #   end
+        # end
+      end
+    
+      dirs = dirs.map { |x| "#{x}/**/*" }
+      dirs
+    end
+    
+    def opts_for_path(path, opts)
+      path = path.gsub('/./', '/')
+      part = File.basename(path, '.*')
+      base = opts[:source_filename] || '.'
+      if base == '.'
+        base = File.expand_path(base)
+      end
+      dir = File.dirname(path)
+      if dir =~ /^\.\/(.+)$/
+        dir = $1
+      end
+      if dir =~ /#{base}\/([^\/]+)/
+        mvt = $1
+      else
+        mvt = nil
+      end
+      
+      opts = {}.deep!
+      opts[:movements] = [mvt]
+      if opts[:score_only]
+        opts[:mode] = :score
+      else
+        opts[:parts] = [part]
+        opts[:mode] = part
+        opts[:line_range] = Lydown::CLI::Diff.diff_line_range(path)
+      end
+      
+      opts
+    end
+    
+    def process(opts)
+      if opts[:line_range] == (nil..nil)
+        puts "No change detected"
+      else
+        Lydown::CLI::Compiler.process(opts)
+      end
+    end
+  end
+end

data/lib/lydown/cli.rb

@@ -4,3 +4,5 @@ module Lydown
 end
 
 require 'lydown/cli/compiler'
+require 'lydown/cli/proofing'
+require 'lydown/cli/diff'

data/lib/lydown/lilypond.rb

@@ -21,12 +21,30 @@ module Lydown
         tmp_target = Tempfile.new('lydown').path
         opts[:output_filename] = tmp_target
         invoke(source, opts)
-        FileUtils.cp(tmp_target + ext, target)
+        
+        if File.file?(tmp_target + ext)
+          FileUtils.cp(tmp_target + ext, target)
+        else
+          copy_pages(tmp_target, target, ext)
+        end
       rescue => e
         puts e.message
         p e.backtrace
       end
       
+      def copy_pages(source, target, ext)
+        page = 1
+        loop do
+          source_fn = source + "-page#{page}" + ext
+          break unless File.file?(source_fn)
+          
+          target_fn = target.dup.insert(target.index(/\.[^\.]+$/), "-page#{page}")
+          
+          FileUtils.cp(source_fn, target_fn)
+          page += 1
+        end
+      end
+      
       def invoke(source, opts = {})
         # Run lilypond, pipe source into its STDIN, and capture its STDERR
         cmd = 'lilypond -lERROR '

data/lib/lydown/rendering/lib.ly

@@ -46,4 +46,21 @@ ten = \markup { \italic ten. }
 ficta = {
   \once \override AccidentalSuggestion #'avoid-slur = #'outside
   \once \set suggestAccidentals = ##t
-}
+}
+
+%{
+  http://www.lilypond.org/doc/v2.18/Documentation/snippets/editorial-annotations#editorial-annotations-adding-links-to-objects
+%}
+#(define (add-link url-strg)
+  (lambda (grob)
+    (let* ((stil (ly:grob-property grob 'stencil)))
+      (if (ly:stencil? stil)
+        (begin
+          (let* (
+             (x-ext (ly:stencil-extent stil X))
+             (y-ext (ly:stencil-extent stil Y))
+             (url-expr (list 'url-link url-strg `(quote ,x-ext) `(quote ,y-ext)))
+             (new-stil (ly:stencil-add (ly:make-stencil url-expr x-ext y-ext) stil)))
+          (ly:grob-set-property! grob 'stencil new-stil)))
+        #f))))
+        

data/lib/lydown/templates/part.erb

@@ -29,14 +29,14 @@
 
 <<
 
-<% if part['settings'][:tempo] %>
-  \tempo "<%= part['settings'][:tempo] %>"
-<% end %>
-
 \new Staff = <%= staff_id %> \with {
 }
 
 \context Staff = <%= staff_id %> {
+  <% if part['settings'][:tempo] %>
+    \tempo "<%= part['settings'][:tempo] %>"
+  <% end %>
+
 <% if score_mode %>\set Staff.instrumentName = #"<%= title %>"<% end %>
   \relative c {
     <% if clef %>

data/lib/lydown/version.rb

@@ -1,3 +1,3 @@
 module Lydown
-  VERSION = "0.7.0"
+  VERSION = "0.7.1"
 end

data/lib/lydown/work.rb

@@ -231,7 +231,7 @@ module Lydown
               preserve_context do
                 process_lydown_file(entry, [
                   {type: :setting, key: 'part', value: part}
-                ])
+                ], line_range: @context[:options][:line_range])
               end
             end
           elsif File.directory?(entry) && recursive
@@ -245,9 +245,47 @@ module Lydown
         end
       end
     end
+    
+    SKIP_ON = "\\set:\"Score.skipTypesetting = ##t\""
+    SHOW_BAR_NUMBERS = "\\set:\"Score.barNumberVisibility = #all-bar-numbers-visible\" |"
+    SKIP_OFF = "\\set:\"Score.skipTypesetting = ##f\""
+    
+    HIGHLIGHT = "\\large \\override:\"NoteHead.color = #red\""
+    NORMAL = "\\large \\override:\"NoteHead.color = #black\""
+    
+    def insert_skip_markers(content, range)
+      unless range.first.nil?
+        lines = content.lines
+        start = range.first - 2; start = 0 if start < 0
+        stop = range.last + 2; stop = lines.size if stop > lines.size
+        
+        lines.insert(stop, "| #{SKIP_ON}")
+        lines.insert(range.last + 1, NORMAL)
+        if start > 0
+          lines.insert(range.first, HIGHLIGHT)
+          lines.insert(start, SHOW_BAR_NUMBERS)
+          lines.insert(start, NORMAL)
+          lines.insert(start, SKIP_OFF)
+          lines.insert(0, SKIP_ON)
+        else
+          lines.insert(0, SHOW_BAR_NUMBERS)
+        end
+        
+        lines.join("\n")
+      else
+        content
+      end
+    end
 
-    def process_lydown_file(path, prefix = [])
-      process(prefix + LydownParser.parse(IO.read(path))) if File.file?(path)
+    def process_lydown_file(path, prefix = [], opts = {})
+      return unless File.file?(path)
+
+      content = IO.read(path)
+      if opts[:line_range]
+        content = insert_skip_markers(content, opts[:line_range])
+      end
+      
+      process(prefix + LydownParser.parse(content))
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lydown
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-30 00:00:00.000000000 Z
+date: 2015-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop
@@ -37,6 +37,8 @@ files:
 - lib/lydown.rb
 - lib/lydown/cli.rb
 - lib/lydown/cli/compiler.rb
+- lib/lydown/cli/diff.rb
+- lib/lydown/cli/proofing.rb
 - lib/lydown/core_ext.rb
 - lib/lydown/errors.rb
 - lib/lydown/lilypond.rb