lydown 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 768154bba0df3c6550e92d7bab1846d78e767652
-  data.tar.gz: a964448d153898925ee16869131f9888a1298ca2
+  metadata.gz: 8b8c837a068f50dd59adac76af318ea85b9e27c0
+  data.tar.gz: a2c3297624f4682fda2c3484334955488a7911ec
 SHA512:
-  metadata.gz: fdc5ae5af05d007763399b2e33b4d7c7ab98050f2abbfd2ffc2f84a49fa8ed6e907762aed1ea577c58bbe98a5ff3d44ab21e11a9382fcd02a830719740fda29d
-  data.tar.gz: 286f620033bd8c01c53bd1dffacb6d715264d4a135674389d892b5602e8c4d23fc3f55f540514a75a1e46b499316cea09766aa9764252e2e9b02b64332e76ab3
+  metadata.gz: 105a386ac25d493b6621877cc983508c41a7e00ee6fa6c5a2d3dc61ceef5358ffce2d0a54ae3f06d71076c884a347b341ee9614b0d67315e2995756b4dfce4af
+  data.tar.gz: 441484711848e46815d6cbbba3478dfc54b37d4bcfab1bb1e5171bed91100f6393da6845f1daca92b005c9baf303c88f66c52a0ea9ee461fe3157486b7969368

data/README.md

@@ -94,6 +94,10 @@ Notes can be repeated using the <code>@</code> placeholder:
 
 (The repeating note placeholder is useful when entering repeated notes with accidentals).
 
+Chords are written using angled brackets, like in lilypond:
+
+    (2<fd>4<ge>) => <f d>2( <g e>4)
+
 ### Rests
 
 Normal rests are written [like in lilypond](http://www.lilypond.org/doc/v2.18/Documentation/notation/writing-rests#rests):
@@ -284,6 +288,10 @@ Multiple arguments can be given, separated by colons. Arguments need to be quote
 
   \!override:AccidentalSuggestion:"#'avoid-slur = #'outside"
 
+Some lilypond command arguments are expected to be quoted. Quotes can be escaped by prefixing them with a backslash:
+
+  \footnote:"#'(-1 . 1)":"\"slurred?\""
+
 ### Inline lyrics
 
 Lyrics for vocal parts can be entered on separate lines prefixed by a > symbol:

data/lib/lydown/core_ext.rb

@@ -108,6 +108,28 @@ class String
   def camelize
     split('_').collect(&:capitalize).join
   end
+  
+  # String unescaping code from here: http://stackoverflow.com/a/20131717
+
+  UNESCAPES = {
+      'a' => "\x07", 'b' => "\x08", 't' => "\x09",
+      'n' => "\x0a", 'v' => "\x0b", 'f' => "\x0c",
+      'r' => "\x0d", 'e' => "\x1b", "\\\\" => "\x5c",
+      "\"" => "\x22", "'" => "\x27"
+  }
+
+  def unescape
+    # Escape all the things
+    gsub(/\\(?:([#{UNESCAPES.keys.join}])|u([\da-fA-F]{4}))|\\0?x([\da-fA-F]{2})/) {
+      if $1
+        if $1 == '\\' then '\\' else UNESCAPES[$1] end
+      elsif $2 # escape \u0000 unicode
+        ["#$2".hex].pack('U*')
+      elsif $3 # escape \0xff or \xff
+        [$3].pack('H2')
+      end
+    }
+  end
 end
 
 class Fixnum

data/lib/lydown/parsing/lydown.treetop

@@ -45,7 +45,7 @@ grammar Lydown
   end
   rule event
     (inline_command / inline_lyrics / voice_selector / barline / duration / 
-      note / standalone_figures / rest / silence / phrasing / tie) white_space*
+      chord / note / standalone_figures / rest / silence / phrasing / tie) white_space*
   end
   rule barline
     ('?|' / ':|][|:' / '[|:' / ':|]' / [\|\.\:]+) <Barline>
@@ -88,6 +88,9 @@ grammar Lydown
   rule note
     note_head octave* accidental_flag? figures? expression* <Note>
   end
+  rule chord
+    '<' note white_space* (note white_space*)* '>' expression* <Chord>
+  end
   rule expression
     (expression_shorthand / expression_longhand / string) <Note::Expression>
   end

data/lib/lydown/parsing/nodes.rb

@@ -114,6 +114,16 @@ module Lydown::Parsing
       end
     end
   end
+  
+  module Chord
+    include Root
+    
+    def to_stream(stream)
+      chord = {type: :chord, notes: []}
+      _to_stream(self, chord[:notes])
+      stream << chord
+    end
+  end
 
   module FiguresComponent
     def to_stream(note)
@@ -271,7 +281,7 @@ module Lydown::Parsing
     module Argument
       def to_stream(cmd)
         if text_value =~ /^"(.+)"$/
-          value = $1
+          value = $1.unescape
         else
           value = text_value
         end

data/lib/lydown/rendering/music.rb

@@ -1,231 +1,7 @@
 require 'lydown/rendering/figures'
+require 'lydown/rendering/notes'
 
 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']
-
-      if @event[:head] == '@'
-        # replace repeating note head
-        @event[:head] = @work['process/last_note_head'] 
-      else
-        @work['process/last_note_head'] = event[:head]
-      end
-
-      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
-    
-    FICTA_CODE = <<EOF
-      \\once \\override AccidentalSuggestion #'avoid-slur = #'outside
-      \\once \\set suggestAccidentals = ##t 
-EOF
-
-    def lilypond_note(event, options = {})
-      head = Accidentals.translate_note_name(@work, event[:head])
-      if options[:head_only]
-        head
-      else
-        if event[:accidental_flag] == '^'
-          accidental_flag = ''
-          prefix =  FICTA_CODE
-        else
-          accidental_flag = event[:accidental_flag]
-          prefix = ''
-        end
-        
-        [
-          prefix,
-          head,
-          event[:octave],
-          accidental_flag,
-          options[:value],
-          lilypond_phrasing(event),
-          event[:expressions] ? event[:expressions].join : '',
-          ' '
-        ].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, no_reset: true)
-
-        # restore macro
-        @work['process/duration_macro'] = macro
-        @work['process/macro_group'] = nil
-      end
-    end
-
-    LILYPOND_EXPRESSIONS = {
-      '_' => '--',
-      '.' => '-.',
-      '`' => '-!'
-    }
-
-    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
-        elsif LILYPOND_EXPRESSIONS[expr]
-          LILYPOND_EXPRESSIONS[expr]
-        else
-          raise LydownError, "Invalid expression #{expr.inspect}"
-        end
-      end
-    end
-
-    def translate_string_expression(expr)
-      expr.gsub(/__([^_]+)__/) {|m| "\\bold { #{$1} }" }.
-           gsub(/_([^_]+)_/) {|m| "\\italic { #{$1} }" }
-    end
-  end
-
   LILYPOND_DURATIONS = {
     '6' => '16',
     '3' => '32'
@@ -294,6 +70,27 @@ EOF
       add_note(@event)
     end
   end
+  
+  class Chord < Base
+    include Notes
+    
+    def translate
+      look_ahead_idx = @idx + 1
+      while event = @stream[look_ahead_idx]
+        case event[:type]
+        when :beam_close
+          @event[:beam_close] = true
+        when :slur_close
+          @event[:slur_close] = true
+        else
+          break
+        end
+        look_ahead_idx += 1
+      end
+      
+      add_chord(@event)
+    end
+  end
 
   class StandAloneFigures < Base
     include Notes
@@ -359,6 +156,7 @@ EOF
 
       if @event[:multiplier]
         value = full_bar_value(@work[:time])
+        @work['process/duration_macro'] = nil unless @work['process/macro_group']
         if value
           @event[:rest_value] = "#{value}*#{@event[:multiplier]}"
           @event[:head] = "#{@event[:head]}#{@event[:rest_value]}"

data/lib/lydown/rendering/notes.rb

@@ -0,0 +1,273 @@
+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, options = {})
+      return add_macro_note(event) if @work['process/duration_macro']
+      
+      if @event[:head] == '@'
+        # replace repeating note head
+        @event[:head] = @work['process/last_note_head'] 
+      else
+        @work['process/last_note_head'] = event[:head]
+      end
+
+      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 options[:no_value] || (value == @work['process/last_value'])
+        value = ''
+      else
+        @work['process/last_value'] = value
+      end
+
+      code = lilypond_note(event, options.merge(value: value))
+      @work.emit(event[:stream] || :music, code)
+    end
+    
+    def add_chord(event, options = {})
+      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
+      
+      notes = event[:notes].map do |note|
+        lilypond_note(note)
+      end
+      
+      options = options.merge(value: value)
+      @work.emit(event[:stream] || :music, lilypond_chord(event, notes, options))
+    end
+    
+    FICTA_CODE = <<EOF
+      \\once \\override AccidentalSuggestion #'avoid-slur = #'outside
+      \\once \\set suggestAccidentals = ##t 
+EOF
+
+    def lilypond_note(event, options = {})
+      head = Accidentals.translate_note_name(@work, event[:head])
+      if options[:head_only]
+        head
+      else
+        if event[:accidental_flag] == '^'
+          accidental_flag = ''
+          prefix =  FICTA_CODE
+        else
+          accidental_flag = event[:accidental_flag]
+          prefix = ''
+        end
+        
+        [
+          prefix,
+          head,
+          event[:octave],
+          accidental_flag,
+          options[:value],
+          lilypond_phrasing(event),
+          event[:expressions] ? event[:expressions].join : '',
+          options[:no_whitespace] ? '' : ' '
+        ].join
+      end
+    end
+
+    def lilypond_chord(event, notes, options = {})
+      [
+        '<',
+        notes.join(' ').strip, # strip trailing whitespace
+        '>',
+        options[:value],
+        lilypond_phrasing(event),
+        event[:expressions] ? event[:expressions].join : '',
+      ].join
+    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, no_reset: true)
+
+        # restore macro
+        @work['process/duration_macro'] = macro
+        @work['process/macro_group'] = nil
+      end
+    end
+
+    LILYPOND_EXPRESSIONS = {
+      '_' => '--',
+      '.' => '-.',
+      '`' => '-!'
+    }
+
+    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
+        elsif LILYPOND_EXPRESSIONS[expr]
+          LILYPOND_EXPRESSIONS[expr]
+        else
+          raise LydownError, "Invalid expression #{expr.inspect}"
+        end
+      end
+    end
+
+    def translate_string_expression(expr)
+      expr.unescape.
+          gsub(/__([^_]+)__/) {|m| "\\bold { #{$1} }" }.
+          gsub(/_([^_]+)_/) {|m| "\\italic { #{$1} }" }
+    end
+  end
+end

data/lib/lydown/rendering.rb

@@ -3,6 +3,7 @@ require 'lydown/work'
 require 'lydown/rendering/base'
 require 'lydown/rendering/comments'
 require 'lydown/rendering/lyrics'
+require 'lydown/rendering/notes'
 require 'lydown/rendering/music'
 require 'lydown/rendering/settings'
 require 'lydown/rendering/staff'

data/lib/lydown/version.rb

@@ -1,3 +1,3 @@
 module Lydown
-  VERSION = "0.6.1"
+  VERSION = "0.6.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lydown
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-13 00:00:00.000000000 Z
+date: 2015-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop
@@ -50,6 +50,7 @@ files:
 - lib/lydown/rendering/lyrics.rb
 - lib/lydown/rendering/movement.rb
 - lib/lydown/rendering/music.rb
+- lib/lydown/rendering/notes.rb
 - lib/lydown/rendering/settings.rb
 - lib/lydown/rendering/staff.rb
 - lib/lydown/rendering/voices.rb