lydown 0.3.0

data/lib/lydown/rendering/movement.rb

@@ -0,0 +1,19 @@
+module Lydown::Rendering
+  module Movement
+    def self.movement_title(work, name)
+      return nil if name.nil? || name.empty?
+      
+      if name =~ /^(?:([0-9])+([a-z]*))\-(.+)$/
+        title = "#{$1.to_i}#{$2}. #{$3.capitalize}"
+      else
+        title = name
+      end
+      
+      if work["movements/#{name}/parts"].empty?
+        title += " - tacet"
+      end
+      
+      title
+    end
+  end
+end

data/lib/lydown/rendering/music.rb

@@ -0,0 +1,362 @@
+require 'lydown/rendering/figures'
+
+module Lydown::Rendering
+  module Accidentals
+    KEY_CYCLE = %w{c- g- d- a- e- b- f c g d a e b f+ c+ g+ d+ a+ e+ b+}
+    C_IDX = KEY_CYCLE.index('c'); A_IDX = KEY_CYCLE.index('a')
+    SHARPS_IDX = KEY_CYCLE.index('f+'); FLATS_IDX = KEY_CYCLE.index('b-')
+    KEY_ACCIDENTALS = {}
+
+    def self.accidentals_for_key_signature(signature)
+      KEY_ACCIDENTALS[signature] ||= calc_accidentals_for_key_signature(signature)
+    end
+
+    def self.calc_accidentals_for_key_signature(signature)
+      unless signature =~ /^([a-g][\+\-]*) (major|minor)$/
+        raise "Invalid key signature #{signature.inspect}"
+      end
+
+      key = $1; mode = $2
+
+      # calculate offset from c major / a minor
+      base_idx = (mode == 'major') ? C_IDX : A_IDX
+      offset = KEY_CYCLE.index(key) - base_idx
+
+      if offset >= 0
+        calc_accidentals_map(KEY_CYCLE[SHARPS_IDX, offset])
+      else
+        calc_accidentals_map(KEY_CYCLE[FLATS_IDX + offset + 1, -offset])
+      end
+    end
+
+    def self.calc_accidentals_map(accidentals)
+      accidentals.inject({}) { |h, a| h[a[0]] = (a[1] == '+') ? 1 : -1; h}
+    end
+
+    def self.lilypond_note_name(note, key_signature = 'c major')
+      value = 0
+      # accidental value from note
+      note = note.gsub(/[\-\+]/) { |c| value += (c == '+') ? 1 : -1; '' }
+      # add key signature value
+      value += accidentals_for_key_signature(key_signature)[note] || 0
+
+      note + (value >= 0 ? 'is' * value : 'es' * -value)
+    end
+
+    # Takes into account the accidentals mode
+    def self.translate_note_name(work, note)
+      if work[:accidentals] == 'manual'
+        key = 'c major'
+      else
+        key = work[:key]
+      end
+      lilypond_note_name(note, key)
+    end
+  end
+
+  module Notes
+    include Lydown::Rendering::Figures
+
+    def add_note(event)
+      return add_macro_note(event) if @work['process/duration_macro']
+
+      @work['process/last_note_head'] = event[:head]
+
+      value = @work['process/duration_values'].first
+      @work['process/duration_values'].rotate!
+
+      add_figures(event[:figures], value) if event[:figures]
+
+      # push value into running values accumulator. This is used to synthesize
+      # the bass figures durations.
+      unless event[:figures]
+        @work['process/running_values'] ||= []
+        if event[:rest_value]
+          @work['process/running_values'] << event[:rest_value]
+        else
+          @work['process/running_values'] << value
+        end
+      end
+
+      # only add the value if different than the last used
+      if value == @work['process/last_value']
+        value = ''
+      else
+        @work['process/last_value'] = value
+      end
+
+      @work.emit(event[:stream] || :music, lilypond_note(event, value: value))
+    end
+
+    def lilypond_note(event, options = {})
+      head = Accidentals.translate_note_name(@work, event[:head])
+      if options[:head_only]
+        head
+      else
+        "%s%s%s%s%s%s " % [
+          head,
+          event[:octave],
+          event[:accidental_flag],
+          options[:value],
+          lilypond_phrasing(event),
+          event[:expressions] ? event[:expressions].join : ''
+        ]
+      end
+    end
+
+    def lilypond_phrasing(event)
+      phrasing = ''
+      if @work['process/open_beam']
+        phrasing << '['
+        @work['process/open_beam'] = nil
+      end
+      if @work['process/open_slur']
+        phrasing << '('
+        @work['process/open_slur'] = nil
+      end
+      phrasing << ']' if event[:beam_close]
+      phrasing << ')' if event[:slur_close]
+      phrasing
+    end
+
+    def lydown_phrasing_open(event)
+      phrasing = ''
+      if @work['process/open_beam']
+        phrasing << '['
+        @work['process/open_beam'] = nil
+      end
+      if @work['process/open_slur']
+        phrasing << '('
+        @work['process/open_slur'] = nil
+      end
+      phrasing
+    end
+
+    def lydown_phrasing_close(event)
+      phrasing = ''
+      phrasing << ']' if event[:beam_close]
+      phrasing << ')' if event[:slur_close]
+      phrasing
+    end
+
+    def add_macro_note(event)
+      @work['process/macro_group'] ||= @work['process/duration_macro'].clone
+      underscore_count = 0
+
+      lydown_note = "%s%s%s%s%s%s%s" % [
+        lydown_phrasing_open(event),
+        event[:head], event[:octave], event[:accidental_flag],
+        lydown_phrasing_close(event),
+        event[:figures] ? "<#{event[:figures].join}>" : '',
+        event[:expressions] ? event[:expressions].join : ''
+      ]
+
+      # replace place holder and repeaters in macro group with actual note
+      @work['process/macro_group'].gsub!(/[_@]/) do |match|
+        case match
+        when '_'
+          underscore_count += 1
+          underscore_count == 1 ? lydown_note : match
+        when '@'
+          underscore_count < 2 ? event[:head] : match
+        end
+      end
+
+      # if group is complete, compile it just like regular code
+      unless @work['process/macro_group'].include?('_')
+        # stash macro, in order to compile macro group
+        macro = @work['process/duration_macro']
+        @work['process/duration_macro'] = nil
+
+        code = LydownParser.parse(@work['process/macro_group'])
+        @work.process(code)
+
+        # restore macro
+        @work['process/duration_macro'] = macro
+        @work['process/macro_group'] = nil
+      end
+    end
+  end
+
+  LILYPOND_DURATIONS = {
+    '6' => '16',
+    '3' => '32'
+  }
+
+  class Duration < Base
+    def translate
+      value = @event[:value].sub(/^[0-9]+/) {|m| LILYPOND_DURATIONS[m] || m}
+
+      if next_event && next_event[:type] == :stand_alone_figures
+        @work['process/figures_duration_value'] = value
+      else
+        @work['process/duration_values'] = [value]
+        @work['process/duration_macro'] = nil unless @work['process/macro_group']
+      end
+    end
+  end
+
+  class Note < Base
+    include Notes
+
+    def translate
+      translate_expressions
+
+      # look ahead and see if any beam or slur closing after note
+      look_ahead_idx = @idx + 1
+      while event = @stream[look_ahead_idx]
+        case @stream[@idx + 1][:type]
+        when :beam_close
+          @event[:beam_close] = true
+        when :slur_close
+          @event[:slur_close] = true
+        else
+          break
+        end
+        look_ahead_idx += 1
+      end
+
+      add_note(@event)
+    end
+
+    LILYPOND_EXPRESSIONS = {
+      '_' => '--',
+      '.' => '-.',
+      '`' => '-!'
+    }
+
+    def translate_expressions
+      return unless @event[:expressions]
+
+      @event[:expressions] = @event[:expressions].map do |expr|
+        if expr =~ /^\\/
+          expr
+        elsif LILYPOND_EXPRESSIONS[expr]
+          LILYPOND_EXPRESSIONS[expr]
+        else
+          raise LydownError, "Invalid expression #{expr.inspect}"
+        end
+      end
+    end
+  end
+
+  class StandAloneFigures < Base
+    include Notes
+
+    def translate
+      add_stand_alone_figures(@event[:figures])
+    end
+  end
+
+  class BeamOpen < Base
+    def translate
+      @work['process/open_beam'] = true
+    end
+  end
+
+  class BeamClose < Base
+    def translate
+    end
+  end
+
+  class SlurOpen < Base
+    def translate
+      @work['process/open_slur'] = true
+    end
+  end
+
+  class SlurClose < Base
+  end
+
+  class Tie < Base
+    def translate
+      @work.emit(:music, '~ ')
+    end
+  end
+
+  class ShortTie < Base
+    include Notes
+
+    def translate
+      note_head = @work['process/last_note_head']
+      @work.emit(:music, '~ ')
+      add_note({head: note_head})
+    end
+  end
+
+  class Rest < 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(@work[:time])
+        if value
+          @event[:rest_value] = "#{value}*#{@event[:multiplier]}"
+          @event[:head] = "#{@event[:head]}#{@event[:rest_value]}"
+        else
+          @event[:head] = "#{@event[:head]}#{@event[:multiplier]}*#{@work[:time]}"
+        end
+        # reset the last value so the next note will be rendered with its value
+        @work['process/last_value'] = nil
+        @work['process/duration_values'] = []
+      end
+
+      add_note(@event)
+    end
+  end
+
+  class Silence < Base
+    include Notes
+
+    def translate
+      add_note(@event)
+    end
+  end
+
+  class FiguresSilence < Base
+    include Notes
+
+    def translate
+      @event[:stream] = :figures
+      add_note(@event)
+    end
+  end
+
+  class DurationMacro < Base
+    def translate
+      if @event[:macro] =~ /^[a-zA-Z_]/
+        macro = @work['macros'][@event[:macro]]
+        if macro
+          if macro =~ /^\{(.+)\}$/
+            macro = $1
+          end
+          @work['process/duration_macro'] = macro
+        else
+          raise LydownError, "Unknown macro #{@event[:macro]}"
+        end
+      else
+        @work['process/duration_macro'] = @event[:macro]
+      end
+    end
+  end
+
+  class Barline < Base
+    def translate
+      barline = @event[:barline]
+      barline = '' if barline == '?|'
+      @work.emit(:music, "\\bar \"#{barline}\" ")
+    end
+  end
+end

data/lib/lydown/rendering/settings.rb

@@ -0,0 +1,107 @@
+module Lydown::Rendering
+  class Setting < Base
+    SETTING_KEYS = [
+      'key', 'time', 'pickup', 'clef', 'part', 'movement',
+      'accidentals', 'beams', 'end_barline', 'macros'
+    ]
+
+    RENDERABLE_SETTING_KEYS = [
+      'key', 'time', 'clef', 'beams'
+    ]
+
+    ALLOWED_SETTING_VALUES = {
+      'accidentals' => ['manual', 'auto'],
+      'beams' => ['manual', 'auto']
+    }
+
+    def translate
+      key = @event[:key]
+      value = @event[:value]
+      level = @event[:level] || 0
+
+      unless (level > 0) || SETTING_KEYS.include?(key)
+        raise Lydown, "Invalid setting (#{key})"
+      end
+
+      if level == 0
+        @work[key] = check_setting_value(key, value)
+        case key
+        when 'part'
+          # when changing parts we repeat the last set time and key signature
+          render_setting('time', @work[:time]) unless @work[:time] == '4/4'
+          key =  @work[:key]
+          render_setting('key', key) unless key == 'c major'
+
+          @work.reset_context(:part)
+        when 'movement'
+          @work.reset_context(:movement)
+        end
+
+        if RENDERABLE_SETTING_KEYS.include?(key)
+          render_setting(key, value)
+        end
+      else
+        # nested settings
+        l, path = 0, ''
+        while l < level
+          path << "#{@work['process/setting_levels'][l]}/"; l += 1
+        end
+        path << key
+        @work[path] = value
+      end
+
+      @work['process/setting_levels'] ||= {}
+      @work['process/setting_levels'][level] = key
+    end
+
+    def check_setting_value(key, value)
+      if ALLOWED_SETTING_VALUES[key]
+        unless ALLOWED_SETTING_VALUES[key].include?(value)
+          raise LydownError, "Invalid value for setting #{key}: #{value.inspect}"
+        end
+      end
+      value
+    end
+
+    def render_setting(key, value)
+      setting = ""
+      case key
+      when 'time'
+        cadenza_mode = @work[:cadenza_mode]
+        should_cadence = value == 'unmetered'
+        @work[:cadenza_mode] = should_cadence
+
+        if should_cadence && !cadenza_mode
+          setting = "\\cadenzaOn "
+        elsif !should_cadence && cadenza_mode
+          setting = "\\cadenzaOff "
+        end
+
+        unless should_cadence
+          signature = value.sub(/[0-9]+$/) { |m| LILYPOND_DURATIONS[m] || m }
+          setting << "\\#{key} #{signature} "
+        end
+      when 'key'
+        # If the next event is a key signature, no need to emit this one
+        e = next_event
+        return if e && (e[:type] == :setting) && (e[:key] == 'key')
+
+        unless value =~ /^([a-g][\+\-]*) (major|minor)$/
+          raise LydownError, "Invalid key signature #{value.inspect}"
+        end
+
+        note = Lydown::Rendering::Accidentals.lilypond_note_name($1)
+        mode = $2
+        setting = "\\#{key} #{note} \\#{mode} "
+      when 'clef'
+        setting = "\\#{key} \"#{value}\" "
+      when 'beams'
+        setting = (value == 'manual') ? '\autoBeamOff ' : '\autoBeamOn '
+      else
+        setting = "\\#{key} #{value} "
+      end
+
+      @work.emit(:music, setting)
+    end
+  end
+end

data/lib/lydown/rendering/staff.rb

@@ -0,0 +1,83 @@
+module Lydown::Rendering
+  module Staff
+    def self.staff_groups(work, movement, parts)
+      model = work['score/order'] || movement['score/order'] || DEFAULTS['score/order']
+      parts_copy = parts.clone
+      
+      groups = []
+      
+      model.each do |group|
+        group = [group] unless group.is_a?(Array)
+        filtered = group.select do |p|
+          if parts_copy.include?(p)
+            parts_copy.delete(p)
+            true
+          end
+        end
+        groups << filtered unless filtered.empty?
+      end
+      
+      # add any remaining unknown parts, in their original order
+      parts_copy.each {|p| groups << [p]}
+      
+      groups
+    end
+    
+    SYSTEM_START = {
+      "brace" => "SystemStartBrace",
+      "bracket" => "SystemStartBracket"
+    }
+    
+    BRACKET_PARTS = %w{soprano alto tenore basso}
+    
+    def self.staff_group_directive(group)
+      if group.size == 1
+        nil
+      elsif BRACKET_PARTS.include?(group.first)
+        "SystemStartBracket"
+      else
+        "SystemStartBrace"
+      end
+    end
+    
+    # renders a systemStartDelimiterHierarchy expression
+    def self.staff_hierarchy(staff_groups)
+      expr = staff_groups.inject('') do |m, group|
+        directive = staff_group_directive(group)
+        if directive
+          m << "(#{directive} #{group.join(' ')}) "
+        else
+          m << "#{group.join(' ')} "
+        end
+        m
+      end
+        
+      "#'(SystemStartBracket #{expr})"
+    end
+    
+    def self.clef(part)
+      DEFAULTS["parts/#{part}/clef"]
+    end
+    
+    def self.beaming_mode(part)
+      beaming = DEFAULTS["parts/#{part}/beaming"]
+      return nil if beaming.nil?
+      
+      case beaming
+      when 'auto'
+        '\autoBeamOn'
+      when 'manual'
+        '\autoBeamOff'
+      else
+        raise LydownError, "Invalid beaming mode (#{beaming.inspect})"
+      end
+    end
+    
+    DEFAULT_END_BARLINE = '|.'
+    
+    def self.end_barline(work, movement)
+      barline = movement['end_barline'] || work['end_barline'] || DEFAULT_END_BARLINE
+      barline == 'none' ? nil : barline
+    end
+  end
+end

data/lib/lydown/rendering.rb

@@ -0,0 +1,45 @@
+require 'lydown/templates'
+require 'lydown/work'
+require 'lydown/rendering/base'
+require 'lydown/rendering/comments'
+require 'lydown/rendering/lyrics'
+require 'lydown/rendering/music'
+require 'lydown/rendering/settings'
+require 'lydown/rendering/staff'
+require 'lydown/rendering/movement'
+
+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)
+      klass.new(e, work, lydown_stream, idx).translate
+    end
+    
+    def class_for_event(e)
+      Lydown::Rendering.const_get(e[:type].to_s.camelize)
+    rescue
+      raise LydownError, "Invalid lydown event: #{e.inspect}"
+    end
+    
+    def part_title(part_name)
+      if part_name =~ /^([^\d]+)(\d+)$/
+        "#{$1.titlize} #{$2.to_i.to_roman}"
+      else
+        part_name.titlize
+      end
+    end
+  end
+  
+  class Base
+    def initialize(event, work, stream, idx)
+      @event = event
+      @work = work
+      @stream = stream
+      @idx = idx
+    end
+  end
+end

data/lib/lydown/templates/lilypond_doc.erb

@@ -0,0 +1,15 @@
+\version "2.18.2"
+
+<% if self['layout'] %>
+\layout {
+}
+<% end %>
+
+\book {
+  \header {
+  }
+  <% self['movements'].each do |n, m| %>
+    <%= Lydown::Templates.render(:movement, self, name: n, movement: m) 
+    %>
+  <% end %>
+}

data/lib/lydown/templates/movement.erb

@@ -0,0 +1,48 @@
+<%
+  score_mode = self['render_opts/mode'] == :score
+  staff_groups = Lydown::Rendering::Staff.staff_groups(
+    self, movement, movement['parts'].keys)
+  parts_in_order = staff_groups.flatten
+  staff_hierarchy = Lydown::Rendering::Staff.staff_hierarchy(staff_groups)
+    
+  parts = parts_in_order.inject({}) do |m, p|
+    m[p] = movement['parts'][p]
+    m
+  end
+  
+  movement_title = Lydown::Rendering::Movement.movement_title(self, name)
+%>
+
+\bookpart {
+  <% if movement_title %>
+    \header { 
+      piece = \markup {
+        \column {
+          \fill-line {\bold \large "<%= movement_title %>"}
+          
+        }
+      }
+    }
+  <% end %>
+  
+  <% if score_mode %>
+    \score {
+      \new StaffGroup <<
+        \set StaffGroup.systemStartDelimiterHierarchy = <%= staff_hierarchy %>
+  <% end %>
+    
+      <% if n = movement['bar_number'] %>
+        \set Score.currentBarNumber = #<%= n %>
+        \set Score.barNumberVisibility = #all-bar-numbers-visible
+        \bar ""
+      <% end %>
+
+      <% parts.each do |n, p| %>
+        <%= Lydown::Templates.render(:part, self, 
+          name: n, part: p, movement: movement) %>
+      <% end %>
+  
+  <% if score_mode %>
+    >> }
+  <% end %>
+}