lydown 0.7.2 → 0.9.0

data/lib/lydown/rendering/settings.rb

@@ -4,7 +4,8 @@ module Lydown::Rendering
     
     SETTING_KEYS = [
       'key', 'time', 'pickup', 'clef', 'part', 'movement', 'tempo',
-      'accidentals', 'beams', 'end_barline', 'macros', 'empty_staves'
+      'accidentals', 'beams', 'end_barline', 'macros', 'empty_staves',
+      'midi_tempo'
     ]
 
     RENDERABLE_SETTING_KEYS = [
@@ -19,34 +20,38 @@ module Lydown::Rendering
 
     def translate
       # if setting while doing a macro, insert it into the current macro group
-      if @work['process/duration_macro'] && @event[:raw]
+      if @context['process/duration_macro'] && @event[:raw]
         return add_macro_event(@event[:raw])
       end
       
       key = @event[:key]
       value = @event[:value]
       level = @event[:level] || 0
-
+      
       unless (level > 0) || SETTING_KEYS.include?(key)
         raise LydownError, "Invalid setting (#{key})"
       end
 
       if level == 0
         value = check_setting_value(key, value)
-        @work[key] = value
+        @context[key] = value
         case key
         when 'part'
-          @work.set_part_context(value)
+          @context.set_part_context(value)
           
           # when changing parts we repeat the last set time and key signature
-          render_setting('time', @work[:time]) unless @work[:time] == '4/4'
+          render_setting('time', @context[:time]) unless @context[:time] == '4/4'
           
-          key =  @work[:key]
+          key =  @context[:key]
           render_setting('key', key) unless key == 'c major'
 
-          @work.reset_context(:part)
+          @context.reset(:part)
         when 'movement'
-          @work.reset_context(:movement)
+          @context.reset(:movement)
+        when 'midi_tempo'
+          movement = @context[:movement]
+          path = "movements/#{movement}/settings/midi_tempo"
+          @context[path] = value
         end
 
         if RENDERABLE_SETTING_KEYS.include?(key)
@@ -56,14 +61,14 @@ module Lydown::Rendering
         # nested settings
         l, path = 0, ''
         while l < level
-          path << "#{@work['process/setting_levels'][l]}/"; l += 1
+          path << "#{@context['process/setting_levels'][l]}/"; l += 1
         end
         path << key
-        @work[path] = value
+        @context[path] = value
       end
 
-      @work['process/setting_levels'] ||= {}
-      @work['process/setting_levels'][level] = key
+      @context['process/setting_levels'] ||= {}
+      @context['process/setting_levels'][level] = key
     end
 
     def check_setting_value(key, value)
@@ -85,9 +90,9 @@ module Lydown::Rendering
       setting = ""
       case key
       when 'time'
-        cadenza_mode = @work[:cadenza_mode]
+        cadenza_mode = @context[:cadenza_mode]
         should_cadence = value == 'unmetered'
-        @work[:cadenza_mode] = should_cadence
+        @context[:cadenza_mode] = should_cadence
 
         if should_cadence && !cadenza_mode
           setting = "\\cadenzaOn "
@@ -119,7 +124,7 @@ module Lydown::Rendering
         setting = "\\#{key} #{value} "
       end
 
-      @work.emit(:music, setting)
+      @context.emit(:music, setting)
     end
   end
 end

data/lib/lydown/rendering/skipping.rb

@@ -37,7 +37,7 @@ module Lydown::Rendering
     # returns index of first event at or after specified line
     def find_line_idx(stream, line, last = false)
       if last
-        stream.reverse_each do |e| 
+        stream.reverse_each do |e|
           return stream.index(e) if e[:line] && e[:line] <= line
         end
         nil

data/lib/lydown/rendering/source_ref.rb

@@ -3,12 +3,12 @@ module Lydown::Rendering
   # for notes in a macro group
   class SourceRef < Base
     def translate
-      return # unless @work['options/proof_mode']
+      return # unless @context['options/proof_mode']
 
       fn = @event[:filename]
-      if fn && fn != @work['process/last_filename']
-        @work['process/last_filename'] = fn
-        @work.emit(@event[:stream] || :music, "%{::#{File.expand_path(fn)}%} ")
+      if fn && fn != @context['process/last_filename']
+        @context['process/last_filename'] = fn
+        @context.emit(@event[:stream] || :music, "%{::#{File.expand_path(fn)}%} ")
       end
     end
   end

data/lib/lydown/rendering/staff.rb

@@ -1,7 +1,7 @@
 module Lydown::Rendering
   module Staff
-    def self.staff_groups(work, movement, parts)
-      model = work['score/order'] || movement['score/order'] || DEFAULTS['score/order']
+    def self.staff_groups(context, movement, parts)
+      model = context['score/order'] || movement['score/order'] || DEFAULTS['score/order']
       parts_copy = parts.clone
       
       groups = []
@@ -59,6 +59,10 @@ module Lydown::Rendering
       DEFAULTS["parts/#{part}/clef"]
     end
     
+    def self.midi_instrument(part)
+      DEFAULTS["parts/#{part}/midi_instrument"]
+    end
+    
     def self.beaming_mode(part)
       beaming = DEFAULTS["parts/#{part}/beaming"]
       return nil if beaming.nil?
@@ -75,8 +79,8 @@ module Lydown::Rendering
     
     DEFAULT_END_BARLINE = '|.'
     
-    def self.end_barline(work, movement)
-      barline = movement['end_barline'] || work['end_barline'] || DEFAULT_END_BARLINE
+    def self.end_barline(context, movement)
+      barline = movement['end_barline'] || context['end_barline'] || DEFAULT_END_BARLINE
       barline == 'none' ? nil : barline
     end
   end

data/lib/lydown/rendering/voices.rb

@@ -2,30 +2,30 @@ module Lydown::Rendering
   class VoiceSelect < Base
     def translate
       if @event[:voice]
-        @work['process/voice_selector'] = "voice#{@event[:voice]}"
+        @context['process/voice_selector'] = "voice#{@event[:voice]}"
       else
-        self.class.render_voices(@work)
+        self.class.render_voices(@context)
       end
     end
     
-    def self.render_voices(work)
-      work['process/voice_selector'] = nil
+    def self.render_voices(context)
+      context['process/voice_selector'] = nil
       
-      music = Lydown::Templates.render(:multi_voice, work, part: work[:part])
+      music = Lydown::Templates.render(:multi_voice, context, part: context[:part])
       
-      work.emit(:music, music)
+      context.emit(:music, music)
       
-      work['process/voices'].each_value do |stream|
+      context['process/voices'].each_value do |stream|
         if stream['lyrics']
           stream['lyrics'].each do |voice, lyrics_stream|
             lyrics_stream.each do |idx, content|
-              work.emit("lyrics/#{voice}/#{idx}", content)
+              context.emit("lyrics/#{voice}/#{idx}", content)
             end
           end
         end
       end
       
-      work['process/voices'] = nil
+      context['process/voices'] = nil
     end
     
     VOICE_COMMANDS = {

data/lib/lydown/templates.rb

@@ -19,4 +19,13 @@ module Lydown
       ERB.new IO.read(File.join(TEMPLATES_DIR, "#{name}.erb")), 0, '<>'
     end
   end
+  
+  module TemplateBinding
+    # Used to bind to instance when rendering templates
+    def template_binding(locals = {})
+      b = binding
+      locals.each {|k, v| b.local_variable_set(k.to_sym, v)}
+      b
+    end
+  end
 end

data/lib/lydown/templates/lilypond_doc.erb

@@ -17,4 +17,4 @@
     <%= Lydown::Templates.render(:movement, self, name: n, movement: m) 
     %>
   <% end %>
-}
+}

data/lib/lydown/templates/movement.erb

@@ -52,6 +52,14 @@
       <% end %>
   
   <% if score_mode %>
-    >> }
+      >>
+      <% if self['render_opts']['format'] == 'midi' %>
+      \midi {
+        <% if tempo = movement['settings/midi_tempo'] %>
+          \tempo <%= tempo %>
+        <% end %>
+      }
+      <% end %> 
+    }
   <% end %>
 }

data/lib/lydown/templates/part.erb

@@ -13,12 +13,16 @@
   score_mode = self['render_opts/mode'] == :score
   
   part['settings'] ||= {
-    'pickup' => @context[:pickup],
-    'key' => @context[:key],
-    'tempo' => @context[:tempo]
+    'pickup' => self[:pickup],
+    'key' => self[:key],
+    'tempo' => self[:tempo]
   }.deep!
 
   clef = Lydown::Rendering::Staff.clef(name)
+  
+  midi_mode = self['render_opts']['format'] == 'midi'
+  midi_instrument = midi_mode && Lydown::Rendering::Staff.midi_instrument(name)
+  
   beaming_mode = Lydown::Rendering::Staff.beaming_mode(name)
   partial = part['settings'][:pickup] ? "\\partial #{part['settings'][:pickup]}" : ""
   
@@ -38,6 +42,11 @@
   <% end %>
 
 <% if score_mode %>\set Staff.instrumentName = #"<%= title %>"<% end %>
+
+<% if midi_instrument %>
+  \set Staff.midiInstrument = #"<%= midi_instrument %>"
+<% end %>
+
   \relative c {
     <% if clef %>
         \clef "<%= clef %>"

data/lib/lydown/translation.rb

@@ -0,0 +1,17 @@
+module Lydown
+  module Translation
+    def self.process(source)
+      output = ''
+      if source[:ripple]
+        output << RippleParser.translate(source[:ripple], source)
+      end
+      if source[:lyrics]
+        output << "\n=lyrics\n#{source[:lyrics]}"
+      end
+      output
+    end
+  end
+end
+
+require 'lydown/translation/ripple'
+

data/lib/lydown/translation/ripple.rb

@@ -0,0 +1,30 @@
+require 'polyglot'
+require 'treetop'
+
+require 'lydown/translation/ripple/nodes'
+require 'lydown/translation/ripple/ripple.treetop'
+
+class RippleParser
+  def self.parse(source, opts = {})
+    parser = self.new
+    ast = parser.parse(source)
+    unless ast
+      error_msg = format_parser_error(source, parser, opts)
+      $stderr.puts error_msg
+      raise LydownError, error_msg
+    end
+    ast
+  end
+
+  def self.translate(source, opts)
+    ast = parse(source)
+    stream = ''
+    ast.translate(stream, opts.merge(source: source))
+  end
+
+  def self.format_parser_error(source, parser, opts)
+    msg = "#{parser.failure_reason} at #{parser.failure_line}:#{parser.failure_column}\n"
+    msg << "  #{source.lines[parser.failure_line - 1].chomp}\n #{' ' * parser.failure_column}^"
+    msg
+  end
+end

data/lib/lydown/translation/ripple/nodes.rb

@@ -0,0 +1,191 @@
+module Lydown::Translation::Ripple
+  class Root < Treetop::Runtime::SyntaxNode
+    def _translate(element, stream, opts)
+      if element.elements
+        element.elements.each do |e|
+          e.respond_to?(:translate) ? 
+            e.translate(stream, opts) : 
+            _translate(e, stream, opts)
+        end
+      end
+      stream
+    end
+
+    def translate(stream = [], opts = {})
+      _translate(self, stream, opts)
+      stream
+    end
+    
+    def source_line(opts)
+      if opts[:source]
+        line, column = opts[:source].find_line_and_column(interval.first)
+        line
+      else
+        nil
+      end
+    end
+    
+    def check_line_break(stream, opts)
+      line = source_line(opts)
+      if line != opts[:last_line]
+        unless stream.empty? || (stream[-1] == "\n")
+          # remove whitespace at end of line
+          stream.gsub!(/\s+$/, '')
+          stream << "\n"
+        end
+        opts[:last_line] = line
+      end
+    end
+  end
+  
+  class RelativeCommand  < Root
+    def translate(stream, opts)
+      opts[:relative_start_octave] = text_value
+    end
+  end
+  
+  class Note < Root
+    def translate(stream, opts)
+      check_line_break(stream, opts)
+      note = {expressions: []}
+      _translate(self, note, opts)
+      expressions = note[:expressions].join
+      expressions << ' ' unless expressions.empty?
+      
+      unless opts[:first_note] || note[:head] =~ /^[rs]/
+        octave = Lydown::Rendering::Octaves.absolute_octave(
+          note[:head], opts[:relative_start_octave] || 'c'
+        )
+        if note[:head] =~ /[',]+$/
+          note[:head].gsub!(/[',]+/, octave)
+        else
+          note[:head] << octave
+        end
+        opts[:first_note] = note[:head]
+      end
+      
+      if opts[:post_macro_value]
+        note[:duration] ||= opts[:post_macro_value]
+        opts[:post_macro_value] = nil
+      end
+
+      stream << "%s%s%s" % [
+        note[:duration],
+        note[:head],
+        expressions
+      ]
+    end
+    
+    class Head < Root
+      def translate(note, opts)
+        head = text_value.dup
+        head.gsub!(/(?<=.{1})b/, '-')
+        head.gsub!(/(?<=.{1})es/, '-')
+        head.gsub!(/(?<=.{1})s/, '+')
+        head.sub!(/([a-g][\+\-]*)/) do |m|
+          Lydown::Rendering::Accidentals.chromatic_to_diatonic(
+            m, opts[:key] || 'c major'
+          )
+        end
+        note[:head] = head
+      end
+    end
+    
+    class Duration < Root
+      def translate(note, opts)
+        note[:duration] = text_value
+      end
+    end
+    
+    class Expression < Root
+      def translate(note, opts)
+        note[:expressions] << text_value
+      end
+    end
+  end
+  
+  class KeySignature < Root
+    def translate(stream, opts)
+      signature = {}
+      _translate(self, signature, opts)
+      opts[:key] = "#{signature[:head]} #{signature[:mode]}"
+      stream << "- key: #{opts[:key]}\n"
+    end
+    
+    class Mode < Root
+      def translate(signature, opts)
+        if text_value =~ /(major|minor)/
+          signature[:mode] = $1
+        end
+      end
+    end
+  end
+  
+  class TimeSignature < Root
+    def translate(stream, opts)
+      opts[:time] = text_value
+      stream << "- time: #{text_value}\n"
+    end
+  end
+  
+  class FullRest < Root
+    def translate(stream, opts)
+      check_line_break(stream, opts)
+      if text_value =~ /R[\d]+\*(\d+)/
+        stream << "R*#{$1} "
+      else
+        stream << "R "
+      end
+    end
+  end
+  
+  class Phrasing < Root
+    def translate(stream, opts)
+      check_line_break(stream, opts)
+      stream << text_value
+    end
+  end
+  
+  class NamedMacro < Root
+    def translate(stream, opts)
+      check_line_break(stream, opts)
+      macro_name = text_value.sub('$', '')
+      if opts[:macros][macro_name]
+        macro = translate_macro(opts[:macros][macro_name])
+        stream << "{#{macro}}"
+        opts[:current_macro] = macro
+        opts[:post_macro_value] = nil
+      else
+        raise LydownError, "Could not find named macro #{macro_name}"
+      end
+    end
+
+    PLACE_HOLDERS = {
+      '#' => '_',
+      '@' => '@',
+      'r' => 'r'
+    }
+    
+    def translate_macro(macro)
+      macro.gsub(/([r#@])([0-9\.]*)/) {|m| "#{$2}#{PLACE_HOLDERS[$1]}"}.
+        gsub(' ', '')
+    end
+    
+    class Stop < Root
+      def translate(stream, opts)
+        if opts[:current_macro]
+          if opts[:current_macro] =~ /([0-9]+\.*)[^0-9]*$/
+            opts[:post_macro_value] = $1
+          end
+        end
+      end
+    end
+  end
+  
+  class Command < Root
+    def translate(stream, opts)
+      cmd = text_value.gsub(' ', ':')
+      stream << " #{cmd} "
+    end
+  end
+end