lydown 0.12.4 → 0.14.0

data/lib/lydown/parsing/lydown.treetop

@@ -34,7 +34,7 @@ grammar Lydown
       comment? <Setting>
   end
   rule setting_key
-    [a-z0-9_]+ <Setting::Key>
+    [a-z0-9_\-]+ <Setting::Key>
   end
   rule setting_value
     (!"\n" !"//" .)* <Setting::Value>
@@ -46,27 +46,31 @@ grammar Lydown
     [ \t]+
   end
   rule event
-    (inline_command / inline_lyrics / voice_selector / barline / source_ref / 
-      grace_duration / duration / standalone_figures / chord / note / rest / 
+    (inline_command / inline_lyrics / voice_selector / repeat_start / volta /
+      repeat_end / barline / source_ref / 
+      duration / standalone_figures / chord / note / rest / 
       silence / phrasing / tie) white_space*
   end
+  rule repeat_start
+    '|:*' [0-9]+ <Repeat::Start>
+  end
+  rule volta
+    '|*' <Repeat::Volta>
+  end
+  rule repeat_end
+    '*|' <Repeat::End>
+  end
   rule barline
-    ('?|' / ':|][|:' / '[|:' / ':|]' / [\|\.\:]+) <Barline>
+    ('?|' / ':|][|:' / '[|:' / ':|]' / [\|\.\:']+) <Barline>
   end
   rule duration
     tuplet_value / duration_value / duration_macro
   end
-  rule grace_duration
-    '$' grace_duration_type* number <GraceDuration>
-  end
-  rule grace_duration_type
-    [\/\^]
-  end
   rule tuplet_value
     number '%' (number '/' number)? <TupletValue>
   end
   rule duration_value
-    duration_number dots* multiplier? <DurationValue>
+    duration_number dots* cross_bar_dotting? multiplier? grace? <DurationValue>
   end
   rule duration_number
     [0-9]+ / 'l'
@@ -77,9 +81,15 @@ grammar Lydown
   rule dots
     '.'+
   end
+  rule cross_bar_dotting
+    '!'
+  end
   rule multiplier
     '*' number ('/' number)*
   end
+  rule grace
+    [°^`]
+  end
   rule duration_macro
     '{' duration_macro__expression '}'
   end
@@ -194,7 +204,10 @@ grammar Lydown
     [\<\>\|\\]? [a-zA-Z_\-\.0-9]+ <Command::Key>
   end
   rule inline_command_argument
-    (string / [^\s\t\n\:]+) <Command::Argument>
+    (string / parenthesized_command_argument / [^\s\t\n\:]+)+ <Command::Argument>
+  end
+  rule parenthesized_command_argument
+    '(' (parenthesized_command_argument / [^\)]+) ')'
   end
   rule voice_selector
     [1234u] ':' <VoiceSelector>

data/lib/lydown/parsing/nodes.rb

@@ -103,10 +103,31 @@ module Lydown::Parsing
   end
 
   class DurationValue < Root
+    GRACE_KIND = {
+      '°' => :grace,
+      '`' => :acciaccatura,
+      '^' => :appoggiatura
+    }
+
     def to_stream(stream, opts)
-      stream << event_hash(stream, opts, {
-        type: :duration, value: text_value
-      })
+      if text_value.strip =~ /^(.+)([°`^])$/
+        event = {
+          type: :grace,
+          value: $1,
+          kind: GRACE_KIND[$2]
+        }
+      else
+        event = {
+          type: :duration,
+          value: text_value.strip
+        }
+        if event[:value] =~ /\!/
+          event[:value].gsub!('!', '')
+          event[:cross_bar_dotting] = true
+        end
+      end
+      
+      stream << event_hash(stream, opts, event)
     end
   end
 
@@ -129,22 +150,6 @@ module Lydown::Parsing
     end
   end
 
-  class GraceDuration < Root
-    GRACE_KIND = {
-      nil => :grace,
-      '/' => :acciaccatura,
-      '^' => :appoggiatura
-    }
-    
-    def to_stream(stream, opts)
-      if text_value =~ /^\$([\/\^])?(\d+)$/
-        stream << event_hash(stream, opts, {
-          type: :grace, value: $2, kind: GRACE_KIND[$1]
-        })
-      end
-    end
-  end
-
   class Note < Root
     def to_stream(stream, opts)
       note = event_hash(stream, opts, {
@@ -413,4 +418,35 @@ module Lydown::Parsing
       end
     end
   end
+  
+  module Repeat
+    class Start < Root
+      def to_stream(stream, opts)
+        ref = {type: :repeat_start, raw: text_value, count: 2}
+        if text_value =~ /(\d+)$/
+          ref[:count] = $1.to_i
+        end
+        
+        stream << event_hash(stream, opts, ref)
+      end
+    end
+    
+    class Volta < Root
+      def to_stream(stream, opts)
+        stream << event_hash(stream, opts, {
+          type: :repeat_volta,
+          raw:  text_value
+        })
+      end
+    end
+
+    class End < Root
+      def to_stream(stream, opts)
+        stream << event_hash(stream, opts, {
+          type: :repeat_end,
+          raw:  text_value
+        })
+      end
+    end
+  end
 end

data/lib/lydown/rendering.rb

@@ -1,4 +1,5 @@
 require 'lydown/templates'
+require 'lydown/inverso'
 require 'lydown/work'
 require 'lydown/rendering/base'
 require 'lydown/rendering/literal'
@@ -6,6 +7,7 @@ require 'lydown/rendering/comments'
 require 'lydown/rendering/lyrics'
 require 'lydown/rendering/notes'
 require 'lydown/rendering/music'
+require 'lydown/rendering/repeats'
 require 'lydown/rendering/settings'
 require 'lydown/rendering/staff'
 require 'lydown/rendering/movement'
@@ -13,6 +15,8 @@ require 'lydown/rendering/command'
 require 'lydown/rendering/voices'
 require 'lydown/rendering/source_ref'
 require 'lydown/rendering/skipping'
+require 'lydown/rendering/layout'
+require 'lydown/rendering/markup'
 
 module Lydown::Rendering
   class << self
@@ -70,6 +74,10 @@ module Lydown::Rendering
     end
     
     def include_files(context, opts)
+      if context.render_mode == :part
+        opts = opts.merge(part: context['render_opts/parts'])
+      end
+      
       filenames = []
       if opts.has_key?(:movement)
         add_includes(filenames, context, :includes, opts)
@@ -93,9 +101,72 @@ module Lydown::Rendering
         when '.ely'
           Lydown::Templates.render(fn, context)
         else
-          "\\include \"#{fn}\""
+          "\\include \"#{File.expand_path(fn)}\""
+        end
+      end
+    end
+    
+    def add_requires(packages, context, key, opts)
+      requires = context.get_setting(key, opts)
+      packages.concat(requires) if requires
+    end
+    
+    def packages_to_load(context, opts)
+      packages = []
+      if opts.has_key?(:movement)
+        add_requires(packages, context, :requires, opts)
+        case context.render_mode
+        when :score
+          add_requires(packages, context, 'score/requires', opts)
+        when :part
+          add_requires(packages, context, 'parts/requires', opts)
+          if opts[:part]
+            add_requires(packages, context, "parts/#{opts[:part]}/requires", opts)
+          end
         end
+      else
+        # paths to be included at top of lilypond doc should be defined under
+        # document/requires
+        add_requires(packages, context, 'document/requires', opts)
       end
+      
+      packages.uniq
+    end
+    
+    def layout_info(context, opts = {})
+      layout = (context.get_merged_setting_tree(:layout, opts) || {}).deep!
+      
+      case context.render_mode
+      when :score
+        layout.deep_merge!(context.get_merged_setting_tree('score/layout', opts) || {})
+      when :part
+        layout.deep_merge!(context.get_merged_setting_tree('parts/layout', opts) || {})
+        layout.deep_merge!(context.get_merged_setting_tree("parts/#{context['render_opts/parts']}/layout", opts) || {})
+      end
+      
+      layout
+    end
+
+    def get_set_variables(context, opts = {})
+      set = (context.get_merged_setting_tree(:set, opts) || {}).deep!
+      
+      case context.render_mode
+      when :score
+        set.deep_merge!(context.get_merged_setting_tree('score/set', opts) || {})
+      when :part
+        set.deep_merge!(context.get_merged_setting_tree('parts/set', opts) || {})
+        set.deep_merge!(context.get_merged_setting_tree("parts/#{context['render_opts/parts']}/set", opts) || {})
+      end
+      
+      set
+    end
+    
+    def lyrics_markup(context, opts = {})
+      if context.render_mode == :part
+        opts = opts.merge(part: context['render_opts/parts'])
+      end
+      
+      context.get_setting('lyrics_markup', opts)
     end
   end
 end

data/lib/lydown/rendering/base.rb

@@ -11,6 +11,27 @@ module Lydown::Rendering
       # do nothing by default
     end
     
+    def prev_event
+      idx = @idx - 1
+      while idx >= 0
+        e = @stream[idx]
+        return e if e && e[:type] != :comment
+        idx -= 1
+      end
+      nil
+    end
+    
+    def find_prev_event(filter)
+      prev = prev_event
+      return nil unless prev
+      
+      filter.each do |k, v|
+        return nil unless prev[k] == v
+      end
+      
+      prev
+    end
+    
     def next_event
       idx = @idx + 1
       while idx < @stream.size

data/lib/lydown/rendering/command.rb

@@ -97,5 +97,58 @@ module Lydown::Rendering
     def cmd_partBreak
       @context.emit(:music, "\\break ") if (@context.render_mode == :part)
     end
+    
+    def cmd_scoreBreak
+      @context.emit(:music, "\\break ") if (@context.render_mode == :score)
+    end
+
+    def cmd_partPageBreak
+      @context.emit(:music, "\\pageBreak ") if (@context.render_mode == :part)
+    end
+    
+    def cmd_scorePageBreak
+      @context.emit(:music, "\\pageBreak ") if (@context.render_mode == :score)
+    end
+    
+    def transform_slur_arguments(args)
+      case args.size
+      when 4
+        args = args.map do |a|
+          case a
+          when '_'
+            '#f'
+          when /\(([0-9\.\-]*),([0-9\.\-]*)\)/
+            "(#{$1.empty? ? '0' : $1} . #{$2.empty? ? '0' : $2})"
+          else
+            a
+          end
+        end
+        args.join(" ")
+      when 1
+        args[0].gsub(/_/, ' (0 . 0) ').
+                gsub (/\(([0-9\.\-]*),([0-9\.\-]*)\)/) do |m|
+                  "(#{$1.empty? ? '0' : $1} . #{$2.empty? ? '0' : $2})"
+                end
+      else
+        raise "Invalid slur shape arguments (#{args.inspect})"
+      end
+    end
+    
+    def cmd_slur
+      arguments = transform_slur_arguments(@event[:arguments])
+      @context.emit(:music, "\\sS #'(#{arguments}) ")
+    end
+    
+    # height-limit + eccentricity
+    def cmd_sHLE
+      args = @event[:arguments]
+      @context.emit(:music, "\\sHL #{args[0]} \\sE #{args[1]} ")
+    end
+    
+    # positions
+    def cmd_sP
+      args = @event[:arguments]
+      @context.emit(:music, "\\sP #{args.join(' ')} ")
+    end
   end
 end

data/lib/lydown/rendering/layout.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+require 'fileutils'
+require 'pathname'
+
+module Lydown::Rendering
+  module Layout
+    def self.define_paper_size(layout)
+      return "" unless layout[:paper]
+      
+      if layout[:paper] =~ /([^\s]+)\s?(portrait|landscape)?/
+        size = $1
+        orientation = $2 || 'portrait'
+      else
+        size = layout[:paper]
+        orientation = 'portrait'
+      end
+      
+      "#(set-paper-size \"#{size.downcase}\" '#{orientation})"
+    end
+    
+    POINT_DIV = {
+      mm: 0.352778,
+      cm: 3.52778
+    }
+
+    MEASUREMENT_RE = /^([0-9\-\.]+)(mm|cm)$/
+
+    def self.to_pp(v)
+      if v =~ MEASUREMENT_RE
+        value = $1
+        unit = $2
+        
+        factor = POINT_DIV[unit.to_sym]
+        "%.1f" % (value.to_f / factor)
+      else
+        raise "Invalid measurement #{v}"
+      end
+    end
+    
+    def self.fmt(v)
+      if v =~ MEASUREMENT_RE
+        "#{$1}\\#{$2}"
+      else
+        raise "Invalid measurement #{v}"
+      end
+    end
+    
+    def self.to_v(v)
+      if v =~ MEASUREMENT_RE
+        $1.to_f
+      else
+        raise "Invalid measurement #{v}"
+      end
+    end
+    
+    # in points
+    def self.staff_space(info)
+      to_v(info[:staff_size]) / 4
+    end
+    
+    # calculates inner vertical margins - that is, the space between the defined
+    # actual margin (used for header/footer) and the music/markup.
+    # an array of four values is returned: top-content, bottom-content
+    def self.calculate_vertical_margins(info)
+      ss = staff_space(info)
+      
+      dist = lambda do |k|
+        (to_v(info["#{k}_content"]) - to_v(info[k])) / ss
+      end
+      
+      staff_dist = lambda {|k| dist[k] + 2}
+      
+      [
+        "%.1f" % staff_dist[:margin_top],
+        "%.1f" % dist[:margin_top],
+        "%.1f" % staff_dist[:margin_bottom]
+      ]
+    end
+  end
+end
+
+