lydown 0.9.0 → 0.10.0

data/lib/lydown/parsing.rb

@@ -23,7 +23,6 @@ class LydownParser
 
     unless ast
       error_msg = format_parser_error(source, parser, opts)
-      $stderr.puts error_msg
       raise LydownError, error_msg
     else
       stream = []
@@ -54,7 +53,7 @@ class LydownParser
   end
 
   def self.format_parser_error(source, parser, opts)
-    msg = opts[:filename] ? "#{opts[:filename]}: " : ""
+    msg = opts[:filename] ? "#{Pathname.relative_pwd(opts[:filename])}: " : ""
     if opts[:nice_error]
       msg << "Unexpected character at line #{parser.failure_line} column #{parser.failure_column}:\n"
     else

data/lib/lydown/parsing/lydown.treetop

@@ -8,10 +8,10 @@ grammar Lydown
     music_stream / lyrics_stream
   end
   rule music_stream
-    '=music' white_space? [\n] music ([\n] !stream_breaker music)*
+    '=' white_space? 'music' white_space? [\n] music ([\n] !stream_breaker music)*
   end
   rule lyrics_stream
-    '=lyrics' stream_idx? white_space? [\n] lyrics_content 
+    '=' white_space? 'lyrics' stream_idx? white_space? [\n] lyrics_content 
       ([\n] !stream_breaker lyrics_content)* <Lyrics>
   end
   rule stream_breaker
@@ -47,7 +47,7 @@ grammar Lydown
   end
   rule event
     (inline_command / inline_lyrics / voice_selector / barline / source_ref / 
-      grace_duration / duration / chord / note / standalone_figures / rest / 
+      grace_duration / duration / standalone_figures / chord / note / rest / 
       silence / phrasing / tie) white_space*
   end
   rule barline
@@ -66,7 +66,10 @@ grammar Lydown
     number '%' (number '/' number)? <TupletValue>
   end
   rule duration_value
-    number dots* multiplier? <DurationValue>
+    duration_number dots* multiplier? <DurationValue>
+  end
+  rule duration_number
+    [0-9]+ / 'l'
   end
   rule number
     [0-9]+
@@ -100,14 +103,17 @@ grammar Lydown
     '<' note white_space* (note white_space*)* '>' expression* <Chord>
   end
   rule expression
-    (expression_shorthand / expression_longhand / string) <Note::Expression>
+    (expression_shorthand / expression_string / expression_longhand) <Note::Expression>
   end
 
   rule expression_shorthand
     [\_\.`]
   end
   rule expression_longhand
-    '\\' [^\s\n]+
+    '\\' [_\^]? [a-zA-Z]+
+  end
+  rule expression_string
+    '\\' '_'? [<>\|]? string
   end
   rule string
     '"' ('\"' / !'"' .)* '"'
@@ -116,7 +122,7 @@ grammar Lydown
     '<' figures_component? (white_space? figures_component)* '>'
   end
   rule figures_component
-    ('_' / [#bh] / ([1-9] [\+\-\!\\'`]*)) <FiguresComponent>
+    ([_\-\.] / [#bh] / ([1-9] [\+\-\!\\'`]*)) <FiguresComponent>
   end
   rule standalone_figures
     duration_value? figures <StandAloneFigures>
@@ -125,10 +131,10 @@ grammar Lydown
     [rR] multiplier* rest_expression* <Rest>
   end
   rule rest_expression
-    (expression_longhand / string) <Note::Expression>
+    (expression_string / expression_longhand) <Note::Expression>
   end
   rule silence
-    [s] multiplier* <Silence>
+    [sS] multiplier* <Silence>
   end
   rule note_head
     [a-g@] octave* accidental* <Note::Head>
@@ -185,7 +191,7 @@ grammar Lydown
     '\\' '!'? inline_command_key (':' inline_command_argument)* <Command>
   end
   rule inline_command_key
-    [a-zA-Z_0-9]+ <Command::Key>
+    [\<\>\|\\]? [a-zA-Z_\-\.0-9]+ <Command::Key>
   end
   rule inline_command_argument
     (string / [^\s\t\n\:]+) <Command::Argument>

data/lib/lydown/parsing/nodes.rb

@@ -11,6 +11,16 @@ module Lydown::Parsing
       stream
     end
     
+    def each_child(ele = nil, &block)
+      ele ||= elements
+      return unless ele
+
+      ele.each do |e|
+        block[e] if e.respond_to?(:to_stream)
+        each_child(e.elements, &block) if e.elements
+      end
+    end
+    
     def to_stream(stream = [], opts = {})
       _to_stream(self, stream, opts)
       stream
@@ -178,7 +188,15 @@ module Lydown::Parsing
       chord = event_hash(stream, opts, {
         type: :chord, notes: []
       })
-      _to_stream(self, chord[:notes], opts)
+      each_child do |c|
+        if c.is_a?(Note)
+          c.to_stream(chord[:notes], opts)
+        elsif c.is_a?(Note::Expression)
+          c.to_stream(chord, opts)
+        end
+      end
+           
+      # _to_stream(self, chord[:notes], opts)
       stream << chord
     end
   end
@@ -243,10 +261,9 @@ module Lydown::Parsing
       rest = event_hash(stream, opts, {
         type: :rest, raw: text_value, head: text_value[0]
       })
-      if text_value =~ /^R(\*([0-9]+))?$/
+      if text_value =~ /^R(\*([0-9]+))?/
         rest[:multiplier] = $2 || '1'
       end
-
       _to_stream(self, rest, opts)
 
       stream << rest
@@ -255,9 +272,14 @@ module Lydown::Parsing
 
   class Silence < Root
     def to_stream(stream, opts)
-      stream << event_hash(stream, opts, {
+      silence = event_hash(stream, opts, {
         type: :silence, raw: text_value, head: text_value[0]
       })
+      if text_value =~ /^S(\*([0-9]+))?/
+        silence[:multiplier] = $2 || '1'
+      end
+      _to_stream(self, silence, opts)
+      stream << silence
     end
   end
 
@@ -334,13 +356,15 @@ module Lydown::Parsing
       stream << cmd
     end
     
-    SETTING_KEYS = %w{time key clef}
+    SETTING_KEYS = %w{time key clef pickup mode nomode}
+    NON_EPHEMERAL_KEYS = %w{time key}
     
     module Key
       def to_stream(cmd, opts)
         cmd[:key] = text_value
         if SETTING_KEYS.include?(text_value)
           cmd[:type] = :setting
+          cmd[:ephemeral] = !NON_EPHEMERAL_KEYS.include?(cmd[:key])
         end
       end
     end

data/lib/lydown/rendering.rb

@@ -1,6 +1,7 @@
 require 'lydown/templates'
 require 'lydown/work'
 require 'lydown/rendering/base'
+require 'lydown/rendering/literal'
 require 'lydown/rendering/comments'
 require 'lydown/rendering/lyrics'
 require 'lydown/rendering/notes'
@@ -13,11 +14,7 @@ require 'lydown/rendering/voices'
 require 'lydown/rendering/source_ref'
 require 'lydown/rendering/skipping'
 
-require 'yaml'
-
 module Lydown::Rendering
-  DEFAULTS = YAML.load(IO.read(File.join(File.dirname(__FILE__), 'rendering/defaults.yml'))).deep!
-  
   class << self
     def translate(work, e, lydown_stream, idx)
       klass = class_for_event(e)
@@ -30,14 +27,43 @@ module Lydown::Rendering
       raise LydownError, "Invalid lydown event: #{e.inspect}"
     end
     
-    def part_title(part_name)
+    def default_part_title(part_name)
       if part_name =~ /^([^\d]+)(\d+)$/
         "#{$1.titlize} #{$2.to_i.to_roman}"
       else
         part_name.titlize
       end
     end
+    
+    def variable_name_infix(infix)
+      infix.capitalize.gsub(/(\d+)/) {|n| n.to_i.to_roman.upcase}.
+        gsub(/[^a-zA-Z]/, '').gsub(/\s+/, '')
+    end
+    
+    VOICE_INDEX = {
+      '1' => 'One',
+      '2' => 'Two',
+      '3' => 'Three',
+      '4' => 'Four'
+    }
+    
+    def voice_variable_name_infix(infix)
+      infix.capitalize.gsub(/(\d+)/) {|n| VOICE_INDEX[n]}
+    end
+    
+    def variable_name(opts)
+      varname = "%s/%s/%s" % [
+        opts[:movement],
+        opts[:part],
+        opts[:stream]
+      ]
+      
+      varname << "/#{opts[:voice]}" if opts[:voice]
+      varname << "/#{opts[:idx]}" if opts[:idx]
+      
+      "\"#{varname}\""
+    end
   end
 end
 
-LY_LIB_DIR = File.join(File.dirname(__FILE__), 'rendering')
+LY_LIB_DIR = File.join(File.dirname(__FILE__), 'ly_lib')

data/lib/lydown/rendering/command.rb

@@ -2,16 +2,63 @@ module Lydown::Rendering
   class Command < Base
     include Notes
     
+    COMMAND_ALIGNMENT = {
+      '<' => '\\right-align',
+      '>' => '\\left-align',
+      '|' => '\\center-align'
+    }
+
     def translate
+      key = @event[:key]
+      if key =~ /([\<\>\|])([a-zA-Z0-9]+)/
+        @event[:alignment] =  COMMAND_ALIGNMENT[$1]
+        key = $2
+      end
+      # Is there a command handler
+      if respond_to?("cmd_#{key}".to_sym)
+        return send("cmd_#{key}".to_sym)
+      end
+      
       if @context['process/duration_macro']
         add_macro_event(@event[:raw] || cmd_to_lydown(@event))
       else
-        once = @event[:once] ? '\once ' : ''
-        cmd = "#{once}\\#{@event[:key]} #{(@event[:arguments] || []).join(' ')} "
+        arguments = (@event[:arguments] || []).map do |a|
+          format_argument(@event[:key], a)
+        end.join(' ')
+        if @event[:key] =~ /^\\/
+          cmd = format_override_shorthand_command
+        else
+          cmd = "\\#{@event[:key]} #{arguments} "
+        end
+        @context.emit(:music, '\once ') if @event[:once]
         @context.emit(:music, cmd)
       end
     end
     
+    def format_override_shorthand_command
+      key = @event[:key] =~ /^\\(.+)$/ && $1
+      arguments = @event[:arguments].map do |arg|
+        case arg
+        when /^[0-9\.]+$/
+          "##{arg}"
+        when /^[tf]$/
+          "###{arg}"
+        else
+          arg
+        end
+      end
+      "\\override #{key} = #{arguments.join(' ')} "
+    end
+    
+    def format_argument(command_key, argument)
+      case command_key
+      when 'tempo', 'mark'
+        "\"#{argument}\""
+      else
+        argument
+      end
+    end
+    
     def cmd_to_lydown(event)
       cmd = "\\#{event[:key]}"
       if event[:arguments]
@@ -20,5 +67,35 @@ module Lydown::Rendering
       end
       cmd
     end
+    
+    def cmd_instr
+      return unless (@context.render_mode == :score)
+      markup = Staff.inline_part_title(
+        @context,
+        part: @context[:part], 
+        name: @event[:arguments] && @event[:arguments][0],
+        alignment: @event[:alignment]
+      )
+      @context.emit(:music, markup)
+    end
+    
+    def cmd_tempo
+      unless @event[:arguments] && @event[:arguments].size == 1
+        raise LydownError, "Invalid or missing tempo argument"
+      end
+      
+      tempo = @event[:arguments].first
+      if tempo =~ /^\((.+)\)$/
+        format = @context['options/format']
+        return unless (format == :midi) || (format == :mp3)
+        tempo = $1
+      end
+      
+      @context.emit(:music, "\\tempo #{tempo} ")
+    end
+    
+    def cmd_partBreak
+      @context.emit(:music, "\\break ") if (@context.render_mode == :part)
+    end
   end
 end

data/lib/lydown/rendering/figures.rb

@@ -1,21 +1,45 @@
 module Lydown::Rendering
   module Figures
+    BLANK_EXTENDER_START  = '<->'
+    BLANK_EXTENDER_STOP   = '<.>'
+    BLANK_EXTENDER        = '<_>'
+
+    EXTENDERS_ON = "\\bassFigureExtendersOn "
+    EXTENDERS_OFF = "\\bassFigureExtendersOff "
+    
     def add_figures(figures, value)
+      # Add fill-in silences to catch up with music stream
       if @context['process/running_values']
+        silence_figures = @event[:tenue] ?
+          @context['process/last_figures'] :
+          (@context['process/blank_extender_mode'] ? '<_>' : 's')
+         
         @context['process/running_values'].each do |v|
-          silence = "s"
+          silence = silence_figures
           if v != @context['process/last_figures_value']
-            silence << v
+            silence = silence + v
             @context['process/last_figures_value'] = v
           end
           @context.emit(:figures, "#{silence} ")
         end
-        @context['process/running_values'] = []
+        @context['process/running_values'] = nil
       end
 
       figures = lilypond_figures(figures)
+      if figures == BLANK_EXTENDER_START
+        @context['process/blank_extender_mode'] = true
+        figures = BLANK_EXTENDER
+        @context.emit(:figures, EXTENDERS_ON)
+      elsif figures == BLANK_EXTENDER_STOP
+        @context['process/blank_extender_mode'] = false
+        figures = BLANK_EXTENDER
+        @event[:figure_extenders_off] = true
+      else
+        @context['process/last_figures'] = figures
+      end
+      
       if value != @context['process/last_figures_value']
-        figures << value
+        figures = figures + value
         @context['process/last_figures_value'] = value
       end
 
@@ -49,7 +73,7 @@ module Lydown::Rendering
       unless next_event
         # if next figures event is not found, check if there is a tenue, and
         # add extenders off flag
-        @event[:figure_extenders_off] = true if @event[:tenue]
+        @event[:figure_extenders_off] = @event[:tenue]
         return
       end
 
@@ -80,9 +104,6 @@ module Lydown::Rendering
       '`' => '\\\\',
       "'" => "/"
     }
-    EXTENDERS_ON = "\\bassFigureExtendersOn "
-    EXTENDERS_OFF = "\\bassFigureExtendersOff "
-
     HIDDEN_FORMAT = "\\once \\override BassFigure #'implicit = ##t"
 
     def next_figures_event

data/lib/lydown/rendering/literal.rb

@@ -0,0 +1,7 @@
+module Lydown::Rendering
+  class Literal < Base
+    def translate
+      @context.emit(:music, "#{@event[:content]} ")
+    end
+  end
+end

data/lib/lydown/rendering/movement.rb

@@ -15,5 +15,66 @@ module Lydown::Rendering
       
       title
     end
+    
+    def self.tacet?(context, name)
+      context["movements/#{name}/parts"].empty?      
+    end
+    
+    PAGE_BREAKS = {
+      'before' => {before: true},
+      'after'  => {after: true},
+      'before and after' => {before: true, after: true},
+      'blank page before' => {blank_page_before: true}
+    }
+    
+    def self.page_breaks(context, opts)
+      setting = case context.render_mode
+      when :score
+        context.get_setting('score/page_break', opts)
+      when :part
+        part = opts[:part] || context[:part] || 
+          (context['options/parts'] ? context['options/parts'][0] : '')
+        context.get_setting(:page_break, opts.merge(part: part)) ||
+          context.get_setting('parts/page_break', opts)
+      else
+        {}
+      end
+      
+      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)
+      groups = []; current_group = []
+      context[:movements].keys.each do |movement|
+        breaks = page_breaks(context, opts.merge(movement: movement))
+        if breaks[:before] || breaks[:blank_page_before]
+          groups << current_group unless current_group.empty?
+          current_group = []
+        end
+        current_group << movement
+      end
+      groups << current_group unless current_group.empty?
+      
+      groups
+    end
+    
+    def self.hide_bar_numbers?(context, opts)
+      context.get_setting(:bar_numbers, opts) == 'hide'
+    end
+    
+    
   end
 end