lydown 0.9.0 → 0.10.0

data/lib/lydown/rendering/music.rb

@@ -3,6 +3,8 @@ require 'lydown/rendering/notes'
 
 module Lydown::Rendering
   LILYPOND_DURATIONS = {
+    '0' => "\\breve",
+    'l' => "\\longa",
     '6' => '16',
     '3' => '32'
   }
@@ -22,7 +24,7 @@ module Lydown::Rendering
         @context['process/grace_mode'] = nil
       end
 
-      value = @event[:value].sub(/^[0-9]+/) {|m| LILYPOND_DURATIONS[m] || m}
+      value = @event[:value].sub(/^[0-9]+|l/) {|m| LILYPOND_DURATIONS[m] || m}
 
       if next_event && next_event[:type] == :stand_alone_figures
         @context['process/figures_duration_value'] = value
@@ -105,7 +107,7 @@ module Lydown::Rendering
         end
         look_ahead_idx += 1
       end
-
+      
       add_note(@event)
     end
   end
@@ -114,6 +116,8 @@ module Lydown::Rendering
     include Notes
     
     def translate
+      translate_expressions
+      
       look_ahead_idx = @idx + 1
       while event = @stream[look_ahead_idx]
         case event[:type]
@@ -194,13 +198,14 @@ module Lydown::Rendering
       translate_expressions
 
       if @event[:multiplier]
-        value = full_bar_value(@context[:time])
+        value = full_bar_value(@context.get_current_setting(:time))
         @context['process/duration_macro'] = nil unless @context['process/macro_group']
         if value
           @event[:rest_value] = "#{value}*#{@event[:multiplier]}"
           @event[:head] = "#{@event[:head]}#{@event[:rest_value]}"
         else
-          @event[:head] = "#{@event[:head]}#{@event[:multiplier]}*#{@context[:time]}"
+          @event[:head] = "#{@event[:head]}#{@event[:multiplier]}*#{
+            @context.get_current_setting(:time)}"
         end
         # reset the last value so the next note will be rendered with its value
         @context['process/last_value'] = nil
@@ -214,7 +219,34 @@ module Lydown::Rendering
   class Silence < Base
     include Notes
 
+    def full_bar_value(time)
+      r = Rational(time)
+      case r.numerator
+      when 1
+        r.denominator.to_s
+      when 3
+        "#{r.denominator / 2}."
+      else
+        nil
+      end
+    end
+
     def translate
+      if @event[:multiplier]
+        value = full_bar_value(@context.get_current_setting(:time))
+        @context['process/duration_macro'] = nil unless @context['process/macro_group']
+        if value
+          @event[:rest_value] = "#{value}*#{@event[:multiplier]}"
+          @event[:head] = "s#{@event[:rest_value]}"
+        else
+          @event[:head] = "s#{@event[:multiplier]}*#{
+            @context.get_current_setting(:time)}"
+        end
+        # reset the last value so the next note will be rendered with its value
+        @context['process/last_value'] = nil
+        @context['process/duration_values'] = []
+      end
+
       add_note(@event)
     end
   end
@@ -233,7 +265,7 @@ module Lydown::Rendering
       Notes.cleanup_duration_macro(@context)
       
       if @event[:macro] =~ /^[a-zA-Z_]/
-        macro = @context['macros'][@event[:macro]]
+        macro = @context.get_current_setting('macros')[@event[:macro]]
         if macro
           if macro =~ /^\{(.+)\}$/
             macro = $1

data/lib/lydown/rendering/notes.rb

@@ -74,10 +74,10 @@ module Lydown::Rendering
 
     # Takes into account the accidentals mode
     def self.translate_note_name(context, note)
-      if context[:accidentals] == 'manual'
+      if context.get_current_setting(:accidentals) == 'manual'
         key = 'c major'
       else
-        key = context[:key]
+        key = context.get_current_setting(:key)
       end
       lilypond_note_name(note, key)
     end
@@ -139,6 +139,8 @@ module Lydown::Rendering
     include Lydown::Rendering::Figures
 
     def add_note(event, options = {})
+      @context.set_setting(:got_music, true)
+      
       return add_macro_note(event) if @context['process/duration_macro']
       
       # calculate relative octave markers for first note
@@ -170,7 +172,7 @@ module Lydown::Rendering
           @context['process/running_values'] << value
         end
       end
-
+      
       # only add the value if different than the last used
       if options[:no_value] || (value == @context['process/last_value'])
         value = ''
@@ -253,6 +255,7 @@ module Lydown::Rendering
         options[:value],
         lilypond_phrasing(event),
         event[:expressions] ? event[:expressions].join : '',
+        ' '
       ].join
     end
 
@@ -379,15 +382,30 @@ module Lydown::Rendering
       '`' => '-!'
     }
 
+    MARKUP_ALIGNMENT = {
+      '<' => 'right-align',
+      '>' => 'left-align',
+      '|' => 'center-align'
+    }
+    
+    DYNAMICS = %w{
+      pppp ppp pp p mp mf f ff fff ffff fp sf sff sp spp sfz rfz
+    }
+
     def translate_expressions
       return unless @event[:expressions]
 
       @event[:expressions] = @event[:expressions].map do |expr|
-        if expr =~ /^(?:\\(_?))?"(.+)"$/
-          placement = ($1 == '_') ? '_' : '^'
-          "#{placement}\\markup { #{translate_string_expression($2)} }"
-        elsif expr =~ /^\\/
-          expr
+        if expr =~ /^(?:\\(_?)([<>\|])?)?"(.+)"$/
+          v_pos = ($1 == '_') ? '_' : '^'
+          content = translate_string_expression($3)
+          if MARKUP_ALIGNMENT[$2]
+            content = "\\#{MARKUP_ALIGNMENT[$2]} { #{content} }"
+          end
+          "#{v_pos}\\markup { #{content} }"
+        elsif expr =~ /^\\([_^]?)(.+)$/
+          v_pos = $1
+          "#{v_pos}\\#{$2}"
         elsif LILYPOND_EXPRESSIONS[expr]
           LILYPOND_EXPRESSIONS[expr]
         else

data/lib/lydown/rendering/settings.rb

@@ -5,7 +5,9 @@ module Lydown::Rendering
     SETTING_KEYS = [
       'key', 'time', 'pickup', 'clef', 'part', 'movement', 'tempo',
       'accidentals', 'beams', 'end_barline', 'macros', 'empty_staves',
-      'midi_tempo'
+      'midi_tempo', 'instrument_names', 'instrument_name_style',
+      'parts', 'score', 'movement_source', 'colla_parte', 'include',
+      'mode', 'nomode', 'bar_numbers'
     ]
 
     RENDERABLE_SETTING_KEYS = [
@@ -15,7 +17,12 @@ module Lydown::Rendering
     ALLOWED_SETTING_VALUES = {
       'accidentals' => ['manual', 'auto'],
       'beams' => ['manual', 'auto'],
-      'empty_staves' => ['hide', 'show']
+      'empty_staves' => ['hide', 'show'],
+      'instrument_names' => ['hide', 'show', 'inline', 'inline-right-align', 'inline-center-align'],
+      'instrument_name_style' => ['normal', 'smallcaps'],
+      'page_break' => ['none', 'before', 'after', 'before and after', 'blank page before'],
+      'mode' => ['score', 'part', 'none'],
+      'bar_numbers' => ['hide', 'shows']
     }
 
     def translate
@@ -32,26 +39,37 @@ module Lydown::Rendering
         raise LydownError, "Invalid setting (#{key})"
       end
 
+      value = check_setting_value(key, value)
+
       if level == 0
-        value = check_setting_value(key, value)
-        @context[key] = value
+        movement = @context[:movement]
         case key
         when 'part'
+          @context[:part] = value
           @context.set_part_context(value)
           
           # when changing parts we repeat the last set time and key signature
-          render_setting('time', @context[:time]) unless @context[:time] == '4/4'
-          
-          key =  @context[:key]
+          time = @context.get_current_setting(:time)
+          key =  @context.get_current_setting(:key)
+
+          render_setting('time', time) unless time == '4/4'
           render_setting('key', key) unless key == 'c major'
 
           @context.reset(:part)
         when 'movement'
+          @context[:movement] = value
           @context.reset(:movement)
-        when 'midi_tempo'
-          movement = @context[:movement]
-          path = "movements/#{movement}/settings/midi_tempo"
-          @context[path] = value
+        when 'include'
+          includes = @context.get_current_setting(:includes) 
+          includes ||= []
+          includes << value
+          @context.set_setting(:includes, includes)
+        when 'mode'
+          set_mode(value.nil? ? :none : value.to_sym)
+        when 'nomode'
+          set_mode(:none)
+        else
+          @context.set_setting(key, value) unless @event[:ephemeral]
         end
 
         if RENDERABLE_SETTING_KEYS.include?(key)
@@ -64,7 +82,7 @@ module Lydown::Rendering
           path << "#{@context['process/setting_levels'][l]}/"; l += 1
         end
         path << key
-        @context[path] = value
+        @context.set_setting(path, value)
       end
 
       @context['process/setting_levels'] ||= {}
@@ -102,7 +120,7 @@ module Lydown::Rendering
 
         unless should_cadence
           signature = value.sub(/[0-9]+$/) { |m| LILYPOND_DURATIONS[m] || m }
-          setting << "\\#{key} #{signature} "
+          setting << "\\time #{signature} "
         end
       when 'key'
         # If the next event is a key signature, no need to emit this one
@@ -118,6 +136,12 @@ module Lydown::Rendering
         setting = "\\#{key} #{note} \\#{mode} "
       when 'clef'
         setting = "\\#{key} \"#{value}\" "
+        # If no music is there, and we're rendering a clef command, we need 
+        # tell lydown to not render a first clef command inside the Staff 
+        # context.
+        unless @context.get_current_setting(:got_music)
+          @context.set_setting(:inhibit_first_clef, true)
+        end
       when 'beams'
         setting = (value == 'manual') ? '\autoBeamOff ' : '\autoBeamOn '
       else
@@ -126,6 +150,10 @@ module Lydown::Rendering
 
       @context.emit(:music, setting)
     end
+    
+    def set_mode(mode)
+      @context['process/mode'] = (mode == :none) ? nil : mode
+    end
   end
 end
 

data/lib/lydown/rendering/skipping.rb

@@ -1,35 +1,68 @@
 module Lydown::Rendering
+  PROOFING_LY_SETTINGS = <<EOF
+    \\paper {
+      indent=0\\mm
+      line-width=110\\mm
+      oddFooterMarkup=##f
+      oddHeaderMarkup=##f
+      bookTitleMarkup = ##f
+      scoreTitleMarkup = ##f
+      page-breaking = #ly:minimal-breaking
+    }
+EOF
+  
   class << self
-    SKIP_ON_CMD = {type: :command, key: 'set', arguments: ['Score.skipTypesetting = ##t']}
-    SKIP_OFF_CMD = {type: :command, key: 'set', arguments: ['Score.skipTypesetting = ##f']}
+    SKIP_GRACE = {type: :literal, content: "\\grace s8"}
     
-    BARLINE = {type: :barline, barline: '|'}
-    BAR_NUMBERS_CMD = {type: :command, key: 'set', arguments: ['Score.barNumberVisibility = #all-bar-numbers-visible']}
+    SKIP_ON_CMD = {type: :literal, content: "\\set Score.skipTypesetting = ##t"}
+    SKIP_OFF_CMD = {type: :literal, content: "\\set Score.skipTypesetting = ##f"}
+
+    SKIP_BARLINE = {type: :literal, content: "\\bar \"\""}
+    SKIP_BAR_NUMBERS_CMD = {type: :literal, content: "\\override Score.BarNumber.break-visibility = ##(#t #t #t) \
+      \\set Score.barNumberVisibility = #(every-nth-bar-number-visible 1)"}
     
-    HIGHLIGHT_NOTES_CMD = {type: :command, key: 'override', arguments: ['NoteHead.color = #red']}
-    NORMAL_NOTES_CMD = {type: :command, key: 'override', arguments: ['NoteHead.color = #black']}
+    HIGHLIGHT_NOTES_CMD = {type: :literal, content: "\\override NoteHead.color = #red"}
+    NORMAL_NOTES_CMD = {type: :literal, content: "\\override NoteHead.color = #black"}
 
     def insert_skip_markers(stream, line_range)
       # find indexes of first and last changed lines
-      changed_first_idx = find_line_idx(stream, line_range.first)
-      changed_last_idx =  find_line_idx(stream, line_range.last, true)
+      changed_first_idx = find_line_idx(stream, line_range[0])
+      changed_last_idx =  find_line_idx(stream, line_range[1], true)
       
       # find index of first line to include
       start_line = line_range.first - 2; start_line = 0 if start_line < 0
       start_idx = find_line_idx(stream, start_line)
       
+      # find index of last line to include
+      end_line = line_range.last + 3
+      end_idx = find_line_idx(stream, end_line)
+      
+      if end_idx && end_idx > changed_last_idx
+        stream.insert(end_idx, SKIP_ON_CMD)
+        stream.insert(end_idx, SKIP_GRACE)
+      end
+      
       if changed_last_idx
         stream.insert(changed_last_idx + 1, NORMAL_NOTES_CMD)
       end
       
       if changed_first_idx
-        stream.insert(changed_first_idx, BARLINE)
-        stream.insert(changed_first_idx, BAR_NUMBERS_CMD)
         stream.insert(changed_first_idx, HIGHLIGHT_NOTES_CMD)
       end
       
       if start_line > 0 && start_idx
+        # Insert an invisible barline (in order to show bar number for first
+        # bar), and show bar numbers on every subsequent barline.
+        stream.insert(start_idx, SKIP_BARLINE)
+        stream.insert(start_idx, SKIP_BAR_NUMBERS_CMD)
+
         stream.insert(start_idx, SKIP_OFF_CMD)
+        # "Help" lilypond correctly render rhythms when skipping on/off by
+        # inserting a silent grace note.
+        # See https://code.google.com/p/lilypond/issues/detail?id=1543&q=skiptypesetting&colspec=ID%20Type%20Status%20Stars%20Owner%20Patch%20Needs%20Summary
+        stream.insert(start_idx, SKIP_GRACE)
+
+        # Skip beginning
         stream.insert(0, SKIP_ON_CMD)
       end
     end

data/lib/lydown/rendering/staff.rb

@@ -1,7 +1,7 @@
 module Lydown::Rendering
   module Staff
-    def self.staff_groups(context, movement, parts)
-      model = context['score/order'] || movement['score/order'] || DEFAULTS['score/order']
+    def self.staff_groups(context, opts, parts)
+      model = context.get_setting('score/order', opts)
       parts_copy = parts.clone
       
       groups = []
@@ -28,7 +28,8 @@ module Lydown::Rendering
       "bracket" => "SystemStartBracket"
     }
     
-    BRACKET_PARTS = %w{soprano alto tenore basso}
+    BRACKET_PARTS = %w{soprano alto tenore basso soprano1 soprano2 
+      alto1 alto2 tenore1 tenore2 basso1 basso2}
     
     def self.staff_group_directive(group)
       if group.size == 1
@@ -42,6 +43,7 @@ module Lydown::Rendering
     
     # renders a systemStartDelimiterHierarchy expression
     def self.staff_hierarchy(staff_groups)
+      directive = nil
       expr = staff_groups.inject('') do |m, group|
         directive = staff_group_directive(group)
         if directive
@@ -51,36 +53,90 @@ module Lydown::Rendering
         end
         m
       end
-        
-      "#'(SystemStartBracket #{expr})"
+      
+      if (staff_groups.size == 1) && (staff_groups[0].size > 1) && directive == "SystemStartBracket"
+        # If all staves are already group, no need to add the system bracket
+        "#'#{expr}"
+      else
+        "#'(SystemStartBar #{expr})"
+      end
     end
     
-    def self.clef(part)
-      DEFAULTS["parts/#{part}/clef"]
+    def self.clef(context, opts)
+      !context.get_setting(:inhibit_first_clef, opts) &&
+        context.get_setting(:clef, opts)
+    end
+    
+    def self.prevent_remove_empty(context, opts)
+      case context.get_setting(:remove_empty, opts)
+      when false, 'false'
+        true
+      else
+        false
+      end
     end
     
-    def self.midi_instrument(part)
-      DEFAULTS["parts/#{part}/midi_instrument"]
+    def self.midi_instrument(context, opts)
+      context.get_setting(:midi_instrument, opts)
     end
     
-    def self.beaming_mode(part)
-      beaming = DEFAULTS["parts/#{part}/beaming"]
+    def self.beaming_mode(context, opts)
+      beaming = context.get_setting(:beaming, opts)
       return nil if beaming.nil?
       
       case beaming
       when 'auto'
-        '\autoBeamOn'
+        '\\set Staff.autoBeaming = ##t'
       when 'manual'
-        '\autoBeamOff'
+        '\\set Staff.autoBeaming = ##f'
       else
         raise LydownError, "Invalid beaming mode (#{beaming.inspect})"
       end
     end
     
-    DEFAULT_END_BARLINE = '|.'
+    def self.staff_id(part)
+      title = Lydown::Rendering.default_part_title(part).gsub(/\s+/, '')
+      "#{title}Staff"
+    end
+    
+    def self.qualified_part_title(context, opts)
+      title = context.get_setting("parts/#{opts[:part]}/title", opts) ||
+              Lydown::Rendering.default_part_title(opts[:part])
+      title.strip
+    end
     
-    def self.end_barline(context, movement)
-      barline = movement['end_barline'] || context['end_barline'] || DEFAULT_END_BARLINE
+    def self.part_title(context, opts)
+      title = qualified_part_title(context, opts)
+
+      if title.empty?
+        "#\"\" "
+      else
+        if context.get_setting('instrument_name_style', opts) == 'smallcaps'
+          "\\markup { \\smallCaps { #{title} } } "
+        else
+          "#\"#{title}\" "
+        end
+      end
+    end
+    
+    def self.inline_part_title(context, opts)
+      title = qualified_part_title(context, opts)
+
+      if title.empty?
+        "#\"\""
+      else
+        if context.get_setting('instrument_name_style', opts) == 'smallcaps'
+          "<>^\\markup { #{opts[:alignment]} \\smallCaps { #{title} } } "
+        else
+          "<>^\\markup { #{opts[:alignment]} { #{title} } } "
+        end
+      end
+    end
+    
+    def self.end_barline(context, opts)
+      return nil if context['global/settings/inhibit_end_barline']
+      
+      barline = context.get_setting('end_barline', opts)
       barline == 'none' ? nil : barline
     end
   end