lygre 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 526592f951e4b589a6c55ddcbdee18ef7316fe81
+  data.tar.gz: 41375a347f0b43ebd94eb7d48b7eec8136b06870
+SHA512:
+  metadata.gz: be30c1c2c467349f386da0be4838753acd35b0b7769420a6752b36cd48046ed72c9bf71dd38077500016cd162d7621b0bfaa787da2d31107c01a3c879ba1caf1
+  data.tar.gz: 61b8761522c20c47a2c41d445a255fd1dfb344fbced567bee020b0aefe6f3c8c526f79beb6df06b0858a478861f7c927b95366df1d4512321aea9c2160202f18

data/bin/grely.rb

@@ -0,0 +1,37 @@
+#!/bin/env ruby
+
+# grely
+
+# one day it will perform
+# conversion gregorio (gabc) -> lilypond
+
+# now it only
+# says if it is able to parse the given input file 
+
+require 'grely'
+
+parser = GabcParser.new
+
+if ARGV.size >= 1 then
+  inputf = ARGV[0]
+  rf = File.open inputf
+else
+  rf = STDIN
+end
+
+input = rf.read
+
+result = parser.parse(input)
+
+if result then
+  STDERR.puts 'grely thinks this is a valid gabc file.'
+  puts LilypondConvertor.new(cadenza: true).convert result.create_score
+  exit 0
+else
+  STDERR.puts 'grely considers the input invalid gabc:'
+  STDERR.puts 
+  STDERR.puts "'#{parser.failure_reason}' on line #{parser.failure_line} column #{parser.failure_column}:"
+  STDERR.puts input.split("\n")[parser.failure_line-1]
+  STDERR.puts (" " * parser.failure_column) + "^"
+  exit 1
+end

data/lib/grely.rb

@@ -0,0 +1,13 @@
+# libraries needed for the gregorio -> lilypond conversion
+
+%w{ 
+gabcscore 
+gabcsemantics
+gabcpitchreader
+lilypondconvertor
+}.each {|f| require_relative File.join('lygre', f)}
+
+# gabc parser
+require 'polyglot'
+require 'treetop'
+Treetop.load File.expand_path('../lib/lygre/gabcgrammar', File.dirname(__FILE__))

data/lib/lygre/gabcpitchreader.rb

@@ -0,0 +1,134 @@
+# encoding: UTF-8
+
+require 'rb-music-theory'
+
+# responsible for converting the 'visual pitch' information
+# contained in gabc to absolute musical pitch
+class GabcPitchReader
+  CLEFS = {:c => "c''", :f => "f'"}
+  CLEF_POSITIONS = 1..4
+
+  def initialize(clef=:c, clef_position=4)
+    unless CLEFS.include? clef
+      raise ArgumentError.new "#{clef} is not a valid clef"
+    end
+    unless CLEF_POSITIONS.include? clef_position
+      raise ArgumentError.new "#{clef_position} is not a valid clef position"
+    end
+
+    @clef = clef
+    @clef_position = clef_position
+
+    init_base
+  end
+
+  attr_reader :clef, :clef_position, :base
+
+  # gets a gabc visual pitch, returns a RbMusicTheory::Note
+  def pitch(visual_note)
+    hnote = visual_note.to_s.ord - 'a'.ord # steps from a - the lowest writable gabc note
+    return @base.diatonic_steps(hnote)
+  end
+
+  private
+
+  def init_base
+    steps = -1 * (3 + # a is 3 steps under the first line
+                  2 * (@clef_position - 1)) # one step for each line and space
+    @base = NoteFactory.create_note(CLEFS[@clef]).diatonic_steps(steps)
+  end
+end
+
+# an interface to create RBMusicTheory::Notes using lilypond notation
+class NoteFactory
+  class << self
+
+    # notesym is a String - absolute pitch in the lilypond format.
+    # (currently alterations are not supported, as they are not necessary
+    # for our dealing with Gregorian chant.)
+    # returns a coresponding RBMusicTheory::Note
+    def create(notesym)
+      unless notesym =~ /^[a-g]('+|,+)?$/i
+        raise ArgumentError.new('#{notesym} is not a valid lilypond absolute pitch')
+      end
+
+      note = notesym[0]
+      octaves = notesym[1..-1]
+
+      n = RBMusicTheory::Note.new note.upcase
+      sign = 0
+      base_octave_shift = -1 # Note.new('C') returns c'=60, not c=48
+      if octaves then
+        sign = (octaves[0] == ',' ? -1 : 1)
+        octave_shift = (octaves.size * sign) + base_octave_shift
+      else
+        octave_shift = base_octave_shift
+      end
+      n += octave_shift * RBMusicTheory::NoteInterval.octave.value # strangely, NoteInterval cannot be multiplied
+
+      return n
+    end
+
+    alias :create_note :create
+    alias :[] :create
+
+    # returns a lilypond absolute pitch for the given RbMusicTheory::Note
+    #
+    # this method doesn't fit well in a *factory*, but
+    # #create translates lilypond pitch to Note and #lily_abs_pitch
+    # does the reverse translation, so maybe just the class should be renamed
+    def lily_abs_pitch(note)
+      octave_shifts = ''
+      octave_diff = note.value - create('c').value
+
+      octave_value = RBMusicTheory::NoteInterval.octave.value
+      octave_shift = octave_diff.abs / octave_value
+      if octave_diff < 0 and (octave_diff.abs % octave_value) > 0 then
+        octave_shift += 1
+      end
+
+      octave_signs = (octave_diff >= 0 ? "'" : ",") * octave_shift
+      note.name.downcase + octave_signs
+    end
+  end
+end
+
+# monkey-patch Note to add step arithmetics
+module RBMusicTheory
+
+  class Note
+
+    def diatonic_steps(steps, scale=nil)
+      if scale.nil? then
+        scale = self.class.new('C').major_scale
+      end
+
+      deg = self.degree_in(scale)
+
+      return scale.degree(deg + steps)
+    end
+
+    # note's degree in a scale
+    def degree_in(scale)
+      degree = scale.note_names.index(self.name)
+      if degree.nil? then
+        raise ArgumentError.new("#{name} is not a member of #{scale.note_names} scale")
+      end
+      degree += 1 # degrees start with 1
+
+      in_base_octave = scale.degree(degree)
+      octave_steps = scale.note_names.size
+      octave_value = RBMusicTheory::NoteInterval.octave.value
+
+      value_difference = self.value - in_base_octave.value
+      octave_difference = value_difference.abs / octave_value
+      if value_difference < 0 then
+        octave_difference *= -1
+      end
+
+      degree += octave_difference * octave_steps
+
+      return degree
+    end
+  end
+end

data/lib/lygre/gabcscore.rb

@@ -0,0 +1,88 @@
+# encoding: UTF-8
+
+# todo: wrap in a module
+
+# initialized by arguments or by assignment in a block;
+# frozen thereafter
+class Immutable
+  def initialize(args={})
+    args.each_pair do |k,v|
+      writer = (k.to_s + '=').to_sym
+      self.send(writer, v)
+    end
+
+    yield self if block_given?
+
+    freeze
+  end
+end
+
+# clean and easy to use music data produced by
+# Gabc::ScoreNode#create_score
+# from the syntax tree created by GabcParser
+class GabcScore < Immutable
+
+  # header fields as Hash
+  attr_accessor :header
+
+  # music information as GabcMusic
+  attr_accessor :music
+end
+
+class GabcMusic < Immutable
+
+  attr_accessor :clef
+
+  # Array of GabcWords
+  attr_accessor :words
+end
+
+class GabcClef < Immutable
+
+  # 'c' or 'f'
+  attr_accessor :pitch
+
+  # Integer 1...4
+  attr_accessor :line
+
+  # Boolean
+  attr_accessor :bemol
+
+  def to_s
+    "#{pitch}#{bemol ? 'b' : ''}#{line}"
+  end
+end
+
+# collection of syllables
+class GabcWord < Array
+
+  def initialize(*args)
+    super(*args)
+    freeze
+  end
+
+  alias_method :each_syllable, :each
+end
+
+class GabcSyllable < Immutable
+
+  # String; may be empty
+  attr_accessor :lyrics
+
+  # Array of GabcNotes and other objects; may be empty
+  attr_accessor :notes
+end
+
+class GabcNote < Immutable
+
+  attr_accessor :pitch
+  attr_accessor :shape
+  attr_accessor :initio_debilis
+  attr_accessor :rhythmic_signs
+  attr_accessor :accent
+end
+
+class GabcDivisio < Immutable
+
+  attr_accessor :type
+end

data/lib/lygre/gabcsemantics.rb

@@ -0,0 +1,138 @@
+# encoding: UTF-8
+
+# classes containing semantics of various nodes
+# instantiated by the GabcParser
+
+require 'treetop'
+require_relative 'gabcscore'
+
+# monkey-patch SyntaxNode
+# to add a useful traversal method
+class Treetop::Runtime::SyntaxNode
+
+  def each_element
+    return if elements.nil?
+    elements.each {|e| yield e }
+  end
+end
+
+module Gabc
+
+  SyntaxNode = Treetop::Runtime::SyntaxNode
+
+  # root node
+  class ScoreNode < SyntaxNode
+
+    # creates and returns a GabcScore from the syntax tree
+    def create_score
+      return GabcScore.new do |s|
+        s.header = header.to_hash
+        s.music = body.create_music
+      end
+    end
+  end
+
+  module HeaderNode
+
+    def to_hash
+      r = {}
+      
+      each_element do |lvl1|
+        lvl1.each_element do |lvl2|
+          lvl2.each_element do |field|
+            if field.is_a? HeaderFieldNode then
+              r[field.field_id.text_value] = field.field_value.text_value
+            end
+          end
+        end
+      end
+
+      return r
+    end
+  end
+
+  class HeaderFieldNode < SyntaxNode
+  end
+
+  class BodyNode < SyntaxNode
+
+    def create_music
+      GabcMusic.new do |m|
+
+        clef = elements.find {|e| e.respond_to? :clef_symbol }
+        if clef != nil then
+          m.clef = GabcClef.new(pitch: clef.clef_symbol.text_value.to_sym, 
+                                line: clef.line_number.text_value.to_i,
+                                bemol: (clef.bemol.text_value == 'b'))
+        end
+
+        words = []
+        each_element do |ele|
+          if ele.is_a? WordNode then
+            words << ele.create_word
+          else
+            ele.each_element do |elel|
+              elel.each_element do |elelel|
+                if elelel.is_a? WordNode then
+                  words << elelel.create_word
+                end
+              end
+            end
+          end
+        end
+        m.words = words
+
+      end
+    end
+  end
+
+  module WordNode
+
+    def create_word
+      w = []
+
+      each_element do |ele|
+        next unless ele.is_a? SyllableNode
+        w << GabcSyllable.new do |s|
+          s.lyrics = ele.lyrics.text_value
+          s.notes = collect_notes ele
+        end
+      end
+
+      return GabcWord.new w
+    end
+
+    private
+
+    # recursively collects notes from a node
+    def collect_notes(node, arr=[])
+      node.each_element do |ele|
+        if ele.is_a? NoteNode then
+          arr << GabcNote.new do |n|
+            n.pitch = ele.note_pitch.text_value.downcase.to_sym
+          end
+        elsif ele.is_a? DivisioNode then
+          arr << GabcDivisio.new do |d|
+            d.type = ele.text_value
+          end
+        else
+          collect_notes ele, arr
+        end
+      end
+
+      return arr
+    end
+  end
+
+  module SyllableNode
+
+  end
+
+  class NoteNode < SyntaxNode
+
+  end
+
+  module DivisioNode
+
+  end
+end

data/lib/lygre/lilypondconvertor.rb

@@ -0,0 +1,165 @@
+# encoding: UTF-8
+
+class LilypondConvertor
+
+  # true - print if given; false - ignore; 'always' - print even if empty
+  DEFAULT_SETTINGS = {
+                      version: true,
+                      notes: true,
+                      lyrics: true,
+                      header: true,
+                      cadenza: false
+                     }
+
+  DEFAULT_CLEF = GabcClef.new(pitch: :c, line: 4, bemol: false)
+
+  # maps gabc divisiones to lilypond bars
+  BARS = {
+          ':' => '\bar "|"',
+          ';' => '\bar "|"',
+          '::' => '\bar "||"',
+          ',' => '\bar "\'"'
+         }
+
+  def initialize(settings={})
+    @settings = DEFAULT_SETTINGS.dup.update(settings)
+
+    # todo: make it possible to freely choose absolute c _pitch_
+    @c_pitch = NoteFactory["c''"]
+
+    @lily_scale = [:c, :d, :e, :f, :g, :a, :b]
+    @gabc_lines = ['', :d, :f, :h, :j]
+  end
+
+  # converts GabcScore to Lilypond source
+  def convert(score)
+    header = score.header.keys.sort.collect do |k|
+      "  #{k} = \"#{score.header[k]}\""
+    end.join "\n"
+
+    notes = []
+    lyrics = []
+
+    clef = score.music.clef
+    if clef == nil then
+      clef = DEFAULT_CLEF
+    end
+    @gabc_reader = GabcPitchReader.new clef.pitch, clef.line
+
+    score.music.words.each do |word|
+      notes << word_notes(word, clef)
+      lyrics << word_lyrics(word)
+    end
+
+    r = ''
+
+    r += "\\version \"2.16.0\"\n\n" if @settings[:version]
+    r += "\\score {\n"
+
+    if @settings[:notes] and
+        (notes.size > 0 or @settings[:notes] == 'always') then
+      r += "  \\absolute {\n"
+
+      if @settings[:cadenza] then
+        r += "    \\cadenzaOn\n"
+      end
+
+      r += "    #{notes.join(" ")}\n" +
+        "  }\n"
+    end
+
+    if @settings[:lyrics] and
+        (lyrics.size > 0 or @settings[:lyrics] == 'always') then
+      r += "  \\addlyrics {\n" +
+        "    #{lyrics.join(" ")}\n" +
+        "  }\n"
+    end
+
+    if @settings[:header] and
+        (header.size > 0 or @settings[:header] == 'always') then
+      r += "  \\header {\n" +
+        "    #{header}\n" +
+        "  }\n"
+    end
+
+    r += "}\n"
+
+    return r
+  end
+
+  # returns the output of #convert 'minimized', with whitespace reduced
+  # and normalized (useful for testing)
+  def convert_min(score)
+    convert(score).gsub(/\s+/, ' ').strip
+  end
+
+  # makes a melisma from a group of notes
+  def melisma(notes)
+    notes[0] = (notes[0].to_s + '(').to_sym
+    notes[-1] = (notes[-1].to_s + ')').to_sym
+    return notes
+  end
+
+  def word_notes(word, clef)
+    r = []
+    word.each_syllable do |syl|
+      notes = syl.notes
+
+      if notes.empty? then
+        r << 's'
+      else
+        sylnotes = notes.collect do |n|
+          if n.is_a? GabcNote then
+            NoteFactory.lily_abs_pitch(@gabc_reader.pitch(n.pitch))
+
+          elsif n.is_a? GabcDivisio then
+            divisio = n.type
+            unless BARS.has_key? divisio
+              raise RuntimeError.new "Unhandled bar type '#{n.type}'"
+            end
+
+            BARS[divisio].dup
+
+          else
+            raise RuntimeError.new "Unknown music content #{n}"
+          end
+        end
+
+        if notes.size >= 2 then
+          sylnotes = melisma sylnotes
+        end
+        r += sylnotes
+      end
+    end
+    return r.join ' '
+  end
+
+  def word_lyrics(word)
+    word.collect do |syll|
+      l = syll.lyrics
+
+      if syll.lyrics.start_with? '*' then
+        l = '"' + syll.lyrics + '"'
+      end
+
+      if syll.lyrics.include? '<' then
+        l = syll.lyrics.gsub(/<i>([^<]+)<\/i>/) do |m|
+          '\italic{' + $1 + '}'
+        end
+        l = '\markup{'+l+'}'
+      end
+
+      if syll.notes.size == 1 and
+          syll.notes.first.is_a? GabcDivisio and
+          syll.lyrics.size > 0 then
+
+        unless l.start_with? '\markup'
+          l = '\markup{'+l+'}'
+        end
+        l = '\set stanza = '+l
+      end
+
+      l
+    end.join ' -- '
+  end
+end