lydown 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9597286c88009e270c73fae97a968f1d946c52e2
-  data.tar.gz: d360df9c114bfc5fefcaf600832e549c42997232
+  metadata.gz: 8609e6ea7dff78ec0b444ea4aeecb7156f24742b
+  data.tar.gz: 523985930d61e49ddbbffb093e2af2b256862ba1
 SHA512:
-  metadata.gz: 603853150a584ee4951388f1565bee07aac65e36639a703d10944de9b011f6530243a9f25fe2abe037f35ce84d33c3bc11a7139fbe7ea16144c4c49662a2dcb2
-  data.tar.gz: 04c071237d29bdaaa0fb78becd234ae5da75fc1321cafd0901fd879b472a09aaf01713c858b9a233a29243d4fa1b62b19cd1f768f85c261eadb6b84d855e2d2a
+  metadata.gz: 825b276f2582fd0bb3cbaed37e1a579978f59da333afffe39f203667e948ce467a6154d65fea6df28cb07218a9f1671aa95257b84e08c8030efdf7863b19bef7
+  data.tar.gz: b676b5b4f22cb575968435084d3e5ecb1a3759c3dd1d4a3e9b3df5fa81b57af529e92f2d4d60f91bc1e0ad93918a3e140e31f239441a4296d4c38bbe2ca5e9b7

data/README.md

@@ -1,5 +1,32 @@
 Lydown is a language and compiler for creating music scores, parts and snippets. The lydown code is compiled to [lilypond](http://lilypond.org/) code and then compiled to PDF, PNG or MIDI files.
 
+- [About](#)
+- [Installation](#)
+- [Hello world in lydown](#)
+- [Compiling the lydown code](#)
+- [Proofing mode](#)
+- [The lydown syntax](#)
+	- [Notes and durations](#)
+	- [Accidentals](#)
+	- [Octaves](#)
+	- [Barlines](#)
+	- [Rests](#)
+	- [Beams, slurs and ties](#)
+	- [Articulation and expression marks](#)
+	- [Repeated articulation and rhythmic patterns: macros](#)
+	- [Named macros](#)
+	- [Clefs, key and time signatures](#)
+	- [Pickup bars](#)
+	- [Lilypond Commands and inline settings](#)
+	- [Inline lyrics](#)
+	- [Stream switching](#)
+	- [Figured bass](#)
+- [Multiple parts](#)
+- [Multiple movements](#)
+- [Multiple voices](#)
+
+## About
+
 Lydown builds on the ideas put forth by lilypond and makes the following improvements:
 
 - a greatly simplified syntax for entering notes, for more rapid note entry and improved legibility.
@@ -60,6 +87,22 @@ To create a MIDI file:
 
     lydown -O --midi helloworld.lydown
 
+
+## Proofing mode
+
+Lydown can be run in a special proofing mode designed to minimize the turnaround time between editing and viewing the result when entering new music or when editing existing music. To run lydown in proofing mode, use the proof subcommand:
+
+    lydown proof
+  
+Lydown will then start to monitor all subdirectories and files in the current directory, and compile them whenever they're changed. Lydown will detect the lines that have changed and insert skip markers in order to speed up compilation and typeset only the music that has actually changed. In addition, notes in the bars that changed will be colored red.
+
+In proof mode, lydown will generate parts and not a score. To include another part for reference along with the part that changed, you can use the include_parts parameter:
+
+    lydown proof --include_parts continuo # or:
+    lydown proof -i continuo
+
+This is useful when editing baroque music for example, or when any other part can give context and aid in verifying the music.
+
 ## The lydown syntax
 
 The lydown syntax is designed for faster note entry, better legibility and minimal boilerplate. The lydown syntax takes the basic ideas put forth by lilypond and simplifies them, with the following main differences:
@@ -204,7 +247,15 @@ Other arbitrary lilypond articulations can be entered after a backslash:
 
     \f cege \p cfaf => c\f e g e c\p f a f
 
-Arbitrary expression marks can be entered as a string following a backslash (for placing it under the note) or a forward slash (for placing it above the note).
+Arbitrary expression markup can be entered as a string following a backslash. Lydown supports basic markdown syntax for formatting the expression:
+
+    c\"hello" // displayed above the note
+    c\_"hello" // displayed below the note
+    c\<"hello" // right-aligned
+    c\|"hello" // centered
+    c\_|"hello" // centered, below the note
+    c\"_hello_" // italic
+    c\"__hello__" // bold
 
 ### Repeated articulation and rhythmic patterns: macros
 
@@ -351,6 +402,19 @@ Multiple lyrics stanzas can be written by including the stanza number in parens:
 Figured bass is entered inline, following notes or even between notes, when
 multiple figures align with a single note.
 
+    c<6>de<5>c // figures are automatically rhythmically aligned 
+    e<7`> // barred figure
+    f<6+> // sharp 6th
+    g<6-> // flat 6th
+    g<6!> // natural sixth
+    a<h> // natural third
+    a<#> // sharp third
+    a<b> // flat third
+    b<7#>b<6_> // extender (tenue) line on sharp third
+    1c2<6><7-> // use durations to change figures over a long note
+    1c2<><7-> // <> is an empty figure
+    c<->dec<.> // extender (tenue) line without figures over the four notes
+
 ## Multiple parts
 
 Multiple parts can be entered in the same file by prefixing each part's content with a -part setting:
@@ -422,6 +486,99 @@ To extract a specific part, we use the -p  switch:
 
 lydown -o -p violino1 score.lydown
 
+## Colla parte and part sources
+
+lydown provides two ways to reuse a part's music in another part. The first is by defining a part source:
+
+    - parts:
+      - violino1:
+        - source: soprano
+
+When dealing situations such as a choral being doubled by many instruments, a more convenient approach would be the <code>colla_parte</code> setting:
+
+    - colla_parte:
+      - soprano: violino1, flute1, flute2, oboe1
+      - alto: violino2, oboe2
+      - tenor: viola, gamba1
+      - basso: gamba2
+
+It is important to remember that the <code>colla_parte</code> setting is the opposite of the part source. Instead of defining a source for a part, it defines the parts that follow the source part.
+
+## Including another part when extracting parts
+
+When extracing parts, some cases, such as recitatives, require displaying another part together with the part to be extracted. Parts can be included in extracted parts using the <code>include_parts</code> setting:
+
+    - parts:
+      - continuo:
+        - include_parts: tenore
+        
+multiple parts can be specified by comma separating them.
+
+## Mode specific code
+
+The <code>\mode</code> and <code>\nomode</code> commands can be used to render code for specific modes. This can be useful when the extracted part should display a different music than the score. The mode command causes anything after it to be rendered only when the rendering mode matches the specified mode.
+
+    \mode:score 4cege \mode:part 4cded \mode:none 1c
+    
+The example above will be render as <code>4cege1c</code> when in score mode, and as <code>4cded1c</code> in the extracted part.
+
+To cancel a mode, use either <code>\mode:none</code> or <code>\nomode</code>
+
+## Staff and system appearance
+
+Numerous settings can be used to control the way staves and systems are displayed. Normally, lydown will follow standard conventions when putting together a score: the different parts will be ordered correctly (e.g. flutes, then oboes, then strings, then vocal parts, then continuo), and braced/bracketed according to convention.
+
+When a single movement switches between different ensembles, for example a recitativo secco followed by a recitativo accompagnato, empty staves may be hidden using setting <code>empty_staves</code> setting:
+
+    - empty_staves: hide
+    
+Normally, instrument names are shown according to convention, to the left of each staff in the first system. To hide the instrument names on the first system, use the <code>instrument_names</code> setting:
+
+    - instrument_names: hide
+    
+The <code>instrument_names</code> setting can also be set to <inline>, in which case the instrument name will be displayed above the beginning of each staff in the first system.
+  
+To show the instrument name inline at any point in the music, use the <code>\instr</code> command:
+
+    - part: flute
+    R*4
+    // when no parameter is given, the part name is used, 
+    // and engraved capitalized with numbers formatted to roman numerals
+    \instr 4c8eg2c
+    ...
+    // when the instrument name is specifed, it is used in place of the 
+    // part name:
+    \instr:"Flute II" 4c8eg2c
+    
+The <code>\instr</code> command can also accept an alignment modifier:
+
+    \<instr // right-aligned
+    \>instr // left-aligned (default)
+    \|instr // centered
+
+Another setting which controls the display of instrument names is <code>instrument_name_style</code> which can be set to <code>normal</code> or <code>smallcaps</code>, in which case the instrument name will be engraved using small caps.
+
+## Rendering MIDI && mp3 files
+
+In order to render the source code into MIDI, the midi format should be specified:
+
+    lydown --midi score.ld
+    
+The playback tempo can be specified either using the <code>midi_tempo</code> setting:
+
+    - midi_tempo: 4=96
+    
+Or inline using the <code>tempo</code> command, putting the tempo in parens:
+
+    \tempo:(4=120)
+    cdef
+    /tempo:(4=54)
+    gabc
+
+Rendering of mp3 files requires both [timidity](http://timidity.sourceforge.net/) and [LAME](http://lame.sourceforge.net/) to be installed. The mp3 format needs to be 
+
 ## Adding a front cover
 
-When creating professional scores and parts, it is customary to add a cover page, with the title of the piece, the composer's name and other general information. Lydown includes a
+When creating professional scores and parts, it is customary to add a cover page, with the title of the piece, the composer's name and other general information.
+
+

data/lib/lydown.rb

@@ -1,6 +1,12 @@
-module Lydown; end
-
 require 'lydown/core_ext'
+require 'lydown/cache'
+
+module Lydown
+  require 'yaml'
+  DEFAULTS = YAML.load(IO.read(File.join(File.dirname(__FILE__), 
+    'lydown/defaults.yml'))).deep!
+end
+
 require 'lydown/errors'
 require 'lydown/parsing'
 require 'lydown/templates'

data/lib/lydown/cache.rb

@@ -0,0 +1,54 @@
+require 'digest/md5'
+require 'msgpack'
+
+module Cache
+  class << self
+    def disable!
+      @disabled = true
+    end
+    
+    def enable!
+      @disabled = false
+    end
+    
+    def hit(*params)
+      return yield if @disabled
+      
+      cache_key = calculate_hash(*params)
+      if result = get(cache_key)
+        result
+      else
+        result = yield
+        set(cache_key, result)
+        result
+      end
+    end
+    
+    def calculate_hash(*params)
+      params.map do |p|
+        Digest::MD5.hexdigest(p.is_a?(String) ? p : p.to_msgpack)
+      end.join('-')
+    end
+      
+    def get(cache_key)
+      fn = filename(cache_key)
+      if File.file?(fn)
+        Marshal.load(IO.read(fn))
+      else
+        nil
+      end
+    rescue
+      nil
+    end
+    
+    def set(cache_key, value)
+      File.open(filename(cache_key), 'w+') do |f|
+        f << Marshal.dump(value)
+      end
+    end
+    
+    def filename(cache_key)
+      "/tmp/lydown-cache-#{cache_key}"
+    end
+  end
+end

data/lib/lydown/cli.rb

@@ -10,3 +10,4 @@ require 'lydown/cli/diff'
 require 'lydown/cli/translation'
 require 'lydown/cli/output'
 require 'lydown/cli/commands'
+require 'lydown/cli/signals'

data/lib/lydown/cli/commands.rb

@@ -12,11 +12,12 @@ module Lydown::CLI
 
     desc "compile [PATH]", "compile the lydown source at PATH"
     method_option :format, aliases: '-f', 
-      default: 'pdf', desc: 'Set output format (pdf/png/ly/midi)', 
-      enum: %w{pdf png ly midi}
+      default: 'pdf', desc: 'Set output format (pdf/png/ly/midi/mp3)', 
+      enum: %w{pdf png ly midi mp3}
     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'
+    method_option :mp3, type: :boolean, desc: 'Set MP3 output format'
 
     method_option :parts, aliases: '-p',
       desc: 'Compile only the specified parts (comma separated)'
@@ -30,31 +31,43 @@ module Lydown::CLI
       desc: 'Set output path'
     method_option :open_target, type: :boolean, aliases: '-O',
       desc: 'Open output file after compilation'
+    method_option :separate, type: :boolean, aliases: '-S',
+      desc: 'Create separate file for each movement'
     method_option :verbose, type: :boolean
     def compile(*args)
       require 'lydown'
       
       opts = Lydown::CLI::Support.copy_options(options)
       opts[:path] = args.first || '.'
-      Lydown::CLI::Support.detect_filename(opts)
       
       # Set format based on direct flag
-      [:png, :ly, :midi].each {|f| opts[:format] = f.to_s if opts[f]}
+      opts[:format] = opts[:format].to_sym if opts[:format]
+      [: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]
       
+      # Detect work directory
+      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
+      end
+
       # compile score
       unless opts[:parts_only] || opts[:parts]
+        $stderr.puts "Processing score..."
         Lydown::CLI::Compiler.process(opts.merge(mode: :score, parts: nil))
       end
 
       # compile parts
-      unless opts[:score_only] || !opts[:parts]
-        parts = opts[:parts]
-        parts.each do |p|
-          Lydown::CLI::Compiler.process(opts.merge(mode: :part, parts: p))
-        end
+      unless opts[:score_only]
+        $stderr.puts "Processing parts..."
+        Lydown::CLI::Compiler.process(opts.merge(mode: :part))
       end
     end
   
@@ -62,15 +75,20 @@ module Lydown::CLI
     method_option :format, aliases: '-f', 
       default: 'pdf', desc: 'Set output format (pdf/png/ly)', 
       enum: %w{pdf png ly}
+    method_option :include_parts, aliases: '-i', desc: 'Include parts (comma separated)'
     def proof(*args)
       require 'lydown'
 
       opts = Lydown::CLI::Support.copy_options(options)
       opts[:path] = args.first || '.'
+
       opts[:proof_mode] = true
+      opts[:include_parts] = opts[:include_parts] && opts[:include_parts].split(',')
       opts[:open_target] = true
     
+      Lydown::CLI::Support.detect_work_directory(opts)
       Lydown::CLI::Support.detect_filename(opts)
+
       Lydown::CLI::Proofing.start_proofing(opts)
     end
     

data/lib/lydown/cli/compiler.rb

@@ -1,78 +1,242 @@
+require 'lydown/cli/output'
+require 'combine_pdf'
+
 module Lydown::CLI::Compiler
   class << self
-    def output_filename(opts)
-      fn = opts[:output_filename]
-      if opts[:movements] && opts[:movements].size == 1
-        fn << "-#{opts[:movements].first}"
-      end
-      if opts[:parts] && opts[:parts].size == 1
-        fn << "-#{opts[:parts].first}"
-      end
-      fn
-    end
+    PARALLEL_COMPILE_OPTIONS = {
+      progress: {
+        title: 'Compile',
+        format: Lydown::CLI::PROGRESS_FORMAT
+      }
+    }
+    
+    PARALLEL_COLLATE_OPTIONS = {
+      progress: {
+        title: 'Collate',
+        format: Lydown::CLI::PROGRESS_FORMAT
+      }
+    }
     
     def process(opts)
       t1 = Time.now
+
       opts = opts.deep_clone
-      # translate lydown code to lilypond code
-      ly_code = ''
-      begin
-        opts[:path] = opts[:source_filename]
-        opts[:nice_error] = true
-        work = Lydown::Work.new(opts)
-        ly_code = work.to_lilypond(opts)
-      rescue LydownError => e
-        $stderr.puts e.message
-        $stderr.puts e.backtrace.join("\n")
-        exit 1
-      rescue => e
-        $stderr.puts "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
-        exit 1
-      end
+      work = create_work_from_opts(opts)
       
-      opts[:output_target] = output_filename(opts)
-
-      if opts[:format] == 'ly'
-        unless opts[:output_target]
-          STDOUT << ly_code
+      jobs = create_jobs_from_opts(work, opts)
+      process_jobs(work, jobs, opts)
+      
+      t2 = Time.now
+      $stderr.puts "Elapsed: #{'%.1f' % [t2-t1]}s"
+    end
+    
+    def create_jobs_from_opts(work, opts)
+      jobs = {compile: [], collate: {}}
+      case opts[:mode]
+      when :score
+        if opts[:separate]
+          # If separate flag is specified, compile each movement separately
+          work.context[:movements].keys.each do |m|
+            add_compile_job(jobs, work, opts.merge(movements: [m]))
+          end
+        else
+          add_compile_job(jobs, work, opts)
+        end
+      when :part
+        # If parts are not specified, compile all extractable parts
+        parts = opts[:parts] || work.context.part_list_for_extraction(opts)
+        
+        parts.each {|p| add_compile_job(jobs, work, opts.merge(parts: p))}
+      when :proof
+        add_compile_job(jobs, work, opts)
+      end
+      jobs
+    end
+    
+    def add_compile_job(jobs, work, opts)
+      if opts[:separate] || (opts[:format] != :pdf)
+        jobs[:compile] << opts
+      else
+        # For now we disable dividing into bookparts, as we have a problem
+        # With page numbers (each bookpart will start at 1).
+        return jobs[:compile] << opts
+        
+        bookparts = Lydown::Rendering::Movement.bookparts(
+          work.context, opts.merge(part: opts[:parts])
+        )
+        if bookparts.size == 1
+          jobs[:compile] << opts
         else
-          begin
-            File.open(opts[:output_target] + '.ly', 'w+') do |f|
-              f.write ly_code
-            end
-          rescue => e
-            $stderr.puts "#{e.class}: #{e.message}"
+          # If compiling pdfs, compilation can be sped up by breaking
+          # the work into bookparts (on page break boundaries), compiling
+          # them in parallel, and then collating the files into a single PDF.
+
+          bookpart_files = []
+          bookparts.each do |movements|
+            tmp_target = Tempfile.new('lydown').path
+            bookpart_files << tmp_target
+            jobs[:compile] << opts.merge(
+              output_target: tmp_target, temp: true, open_target: false,
+              movements: movements
+            )            
           end
+          jobs[:collate][output_filename(opts)] = bookpart_files
         end
+      end
+    end
+    
+    def process_jobs(work, jobs, opts)
+      if jobs[:compile].size == 1
+        run_compile_job(work, jobs[:compile][0])
+      else
+        Parallel.each(jobs[:compile], PARALLEL_COMPILE_OPTIONS.clone) do |job|
+          job = job.deep_clone
+          job[:no_progress_bar] = true
+          run_compile_job(work, job)
+        end
+      end
+      
+      collate_pdfs(jobs[:collate], opts) unless jobs[:collate].empty?
+    end
+    
+    def collate_pdfs(collate_map, opts)
+      if collate_map.size == 1
+        collate_bookparts_into_pdf(collate_map.keys[0], collate_map.values[0], opts)
+      else
+        Parallel.each(collate_map, PARALLEL_COLLATE_OPTIONS.clone) do |fn, tempfiles|
+          collate_bookparts_into_pdf(fn, tempfiles, opts)
+        end
+      end
+    end
+    
+    def collate_bookparts_into_pdf(output_filename, source_filenames, opts)
+      pdf = CombinePDF.new
+      source_filenames.each do |fn|
+        pdf << CombinePDF.load(fn + ".pdf")
+      end
+      pdf.save output_filename + ".pdf"
+      
+      system("open #{output_filename}.pdf") if opts[:open_target]
+    end
+    
+    def run_compile_job(work, opts)
+      ly_code = work.to_lilypond(opts)
+      opts[:output_target] = output_filename(opts) unless opts[:temp]
+
+      if opts[:format] == :ly
+        process_ly_target(ly_code, opts)
       else
         compile(ly_code, opts)
       end
-      t2 = Time.now
-      $stderr.puts "Elapsed: #{'%.1f' % [t2-t1]}s"
+    rescue => e
+      if e.is_a?(LydownError)
+        $stderr.puts e.message
+      else
+        $stderr.puts "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+      end
+      if opts[:proof_mode]
+        `osascript -e beep`
+        return
+      else
+        exit(1)
+      end
+    end
+    
+    def process_ly_target(ly_code, opts)
+      unless opts[:output_target]
+        STDOUT << ly_code
+      else
+        File.open(opts[:output_target] + '.ly', 'w+') do |f|
+          f.write ly_code
+        end
+        open_target(opts) if opts[:open_target]
+      end
+    end
+    
+    def output_filename(opts)
+      fn = opts[:output_filename].dup
+      if opts[:movements] && opts[:movements].size == 1
+        fn << "-#{opts[:movements].first}"
+      end
+      if opts[:parts] && (opts[:parts].is_a?(String) || (opts[:parts].size == 1))
+        part_name = opts[:parts].is_a?(String) ? opts[:parts] : opts[:parts].first
+        fn << "-#{part_name}"
+      elsif (opts[:mode] == :score) && !([:midi, :mp3].include? opts[:format])
+        # Don't add score postfix for midi or mp3 compilation
+        fn << '-score'
+      end
+      fn
+    end
+    
+    def create_work_from_opts(opts)
+      opts[:path] = opts[:source_filename]
+      opts[:nice_error] = true
+      Lydown::Work.new(opts)
     end
 
     def compile(ly_code, opts)
-      opts = opts.deep_clone
-      begin
-        Lydown::Lilypond.compile(ly_code, opts)
-      rescue LydownError => e
-        $stderr.puts e.message
-        $stderr.puts e.backtrace.join("\n")
-      rescue => e
-        $stderr.puts "#{e.class}: #{e.message}"
-        $stderr.puts e.backtrace.join("\n")
+      if opts[:format] == 'mp3'
+        return compile_mp3(ly_code, opts)
       end
+      
+      opts = opts.deep_clone
+      Lydown::Lilypond.compile(ly_code, opts)
+      open_target(opts) if opts[:open_target]
 
-      if opts[:open_target]
-        filename = "#{opts[:output_target]}.#{opts[:format]}"
-        
-        unless File.file?(filename)
-          filename = "#{opts[:output_target]}-page1.#{opts[:format]}"
-        end
+    rescue CompilationAbortError
+      $stderr.puts "Compilation aborted"
+    rescue LydownError => e
+      $stderr.puts e.message
+      $stderr.puts e.backtrace.join("\n")
+    rescue => e
+      $stderr.puts "#{e.class}: #{e.message}"
+      $stderr.puts e.backtrace.join("\n")
+    end
+    
+    def compile_mp3(ly_code, opts)
+      opts2 = opts.merge(format: 'midi').deep_clone
+      Lydown::Lilypond.compile(ly_code, opts2)
 
-        # Mac OSX specific probably
+      midi_filename = "#{opts[:output_target]}.midi"
+      mp3_filename =  "#{opts[:output_target]}.mp3"
+      cmd = "timidity -Ow -o - #{midi_filename} | lame - #{mp3_filename}"
+      $stderr.puts "Converting to MP3..."
+      Open3.popen2e(cmd) do |input, output, wait_thr|
+        input.close
+        output.read
+        output.close
+      end
+      open_target(opts) if opts[:open_target]
+    rescue CompilationAbortError
+      $stderr.puts "Compilation aborted"
+    end
+    
+    def open_target(opts)
+      filename = "#{opts[:output_target]}.#{opts[:format]}"
+      
+      unless File.file?(filename)
+        filename2 = "#{opts[:output_target]}-page1.#{opts[:format]}"
+        unless File.file?(filename2)
+          raise "Could not find target file #{filename}"
+        else
+          filename = filename2
+        end
+      end
+      
+      if opts[:format] == :midi
+        open_midi_target(filename)
+      else
         system("open #{filename}")
       end
     end
+    
+    def open_midi_target(filename)
+      $stderr << "Playing #{filename}..."
+      Open3.popen2e("timidity #{filename}") do |input, output, wait_thr|
+        input.close
+        output.read
+        output.close
+      end
+    end
   end
 end