lydown 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 66935404398a57aa09da31ebddd911edae7227fe
+  data.tar.gz: 6bc6875c3b2e2187140a91bb586b53411aeb57c3
+SHA512:
+  metadata.gz: 28dcdb1e4501356d371f3ff217af806f966a37fe24611fe7f33426ec264d80b197fc609441fef6953b3929d9239436289950e05983d0bbf15f8fc58770663392
+  data.tar.gz: 36a98eb309977703065fb6feb0dc5284b2f78d7b241f40606f0098087980e70415258d9df13d30b06854ac40b92a93fec84bdad93cb6fe9acaea565d3d8e76c0

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Sharon Rosner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,357 @@
+Lydown is a language and compiler for creating music scores, parts and snippets. The lydown code is compiled to [lilypond](http://lilypond.org/) code and then compiled to PDF, PNG or MIDI files.
+
+Lydown builds on the ideas put forth by lilypond and makes the following improvements:
+
+- a greatly simplified syntax for entering notes, for more rapid note entry and improved legibility.
+- ability to enter lyrics and bass figures interspersed with the music.
+- rhythmic macros for rapid entry of repeated rhythmic patterns.
+- zero lilypond boilerplate code.
+- a sane file/folder structure for creating multi-part, multi-movement works with automatic part extraction.
+
+## Installation
+
+Before installing lydown, you'll need to have installed [lilypond](http://lilypond.org/download.html).
+
+You can verify that lilypond is correctly installed by running the following command:
+
+    lilypond --version
+
+If everything's ok, you can proceed by installing lydown:
+
+    gem install lydown
+
+and verifying that it too works:
+
+    lydown --version
+
+## Hello world in lydown
+
+    // helloworld.lydown
+    - key: d major
+    - time: 2/4
+    4d\"Hello world!" 6c#bag 3f#gag6f#d 4e
+
+And here's the equivalent lilypond code:
+
+    \version "2.18.2"
+    relative c' {
+      \key d major
+      \time 2/4
+       d'4\"Hello world!" cs16 b a g fs32 g a g fs16 d e4
+    }
+
+## Compiling the lydown code
+
+The lydown command line tool can compile the code into lilypond code, PDF, PNG, or MIDI. The program creates an output file with the same name as the input file and the corresponding extension. Specifiying the -O switch causes the output to be opened immediately.
+
+To create a lilypond file:
+
+    lydown -O --ly helloworld.lydown
+
+To create a PDF file:
+
+    lydown -O --pdf helloworld.lydown
+
+To create a PNG file:
+
+    lydown -O --png helloworld.lydown
+
+To create a MIDI file:
+
+    lydown -O --midi helloworld.lydown
+
+## The lydown syntax
+
+The lydown syntax is designed for faster note entry, better legibility and minimal boilerplate. The lydown syntax takes the basic ideas put forth by lilypond and simplifies them, with the following main differences:
+
+- musical context (staves, parts, etc) is implicit rather than explicit.
+- whitespace between notes is optional.
+- durations come before notes.
+- duration macros allow rapid entry of repeated rhythmic patterns (such as dotted rhythm).
+
+It must be stressed that lydown is made to process music that is relatively simple, and it was designed to support the processing of baroque music in particular. Therefore, a lot of stuff that is possible with plain lilypond would not be possible with lydown.
+
+For the sake of this tutorial, some familiarity with the concepts and syntax of lilypond is presumed. The lydown code will be shown alongside its lilypond equivalent.
+
+### Notes and durations
+
+In lydown, durations are entered before the note to which they refer, and they stay valid for subsequent notes, until a new value is entered:
+
+    4c8de2f => c4 d8 e f2
+
+In addition to the usual values (1, 2, 4, 8, 16, 32 etc), lydown adds two shortcuts for commonly used values: 6 for 16th notes and 3 for 32th notes:
+
+    8c6de3fefefede2f => c8 d16 e f32 e f e f e d e f2
+
+Augmentation dots are entered like in lilypond:
+
+    8.c6d 8.e6f 2g => c8. d16 e8. f16 g2
+    8..g 3g 4c => g8.. g32 c4
+
+### Rests
+
+Normal rests are written [like in lilypond](http://www.lilypond.org/doc/v2.18/Documentation/notation/writing-rests#rests):
+
+    4ce2r => c4 e r2
+
+Full bar rests are [similar to lilypond](http://www.lilypond.org/doc/v2.18/Documentation/notation/writing-rests#full-measure-rests), except there's no need to enter the rest value (it is implicit in the time signature):
+
+    - time: 3/4
+    // 4 bar rest in the middle
+    2c4e R*4 2.g
+
+### Accidentals
+
+Accidentals are entered using + and -
+
+    8cgb-c2a => c8 g bb c a2
+
+In lydown notes follow the key signature by default:
+
+    - key: g major
+    8g6fedcba2g => g8 fs16 e d c b a g2
+
+The accidental mode can be changed by specifiying the manual accidental mode:
+
+    - key: g major
+    - accidentals: manual
+    8g6f+edcba2g
+
+In the default, automatic mode, when deviating from the key signature the accidental must be repeated for each note, regardless of barlines.
+
+In the [same manner as lilypond](http://www.lilypond.org/doc/v2.18/Documentation/notation/writing-pitches#accidentals), accidentals can be forced by following the note name and accidental with a ! (for a reminder), or ? (for a cautionary accidental in parentheses):
+
+      cc+c+!cc? => c cs cs! c c?
+
+A ficta accidental (an non-original accidental that appears above the staff) can be entered using the ^ symbol after the accidental:
+
+      cdef+^g
+
+### Octaves
+
+Like in lilypond's [relative mode](http://www.lilypond.org/doc/v2.18/Documentation/notation/writing-pitches#relative-octave-entry), lydown uses ' and , for moving between octaves. The starting point is always c (that is c°).
+
+### Barlines
+
+Just like in lilypond, barlines are taken care of automatically according to the time signature. Final bar lines and repeat bar lines can be entered explicitly by using shorthand syntax:
+
+    |: cege :|: cfaf :|
+
+When entering unmetered music, an invisible barline can be added in order to provide line breaks:
+
+    -time: unmetered
+    cdef ?| gag
+
+### Beams, slurs and ties
+
+Lydown uses automatic beaming as the default, except in the case of vocal parts (see [document settings](#settings)). Auto beaming can be
+
+Beaming and sluring is similar to lilypond, except the beam/slur start comes before the note:
+
+    8(cdef)g[6fe]4f => c8( d e f) g f16[ e] f4
+
+a regular tie is written just like in lilypond:
+
+    4g~6gfed2c => g4 ~ g16 f e d c2
+
+Lydown also supports a shortened tie form, where the tied note is not repeated:
+
+    4g6&fed2c => g4 ~ g16 f e d c2
+
+### Articulation and expression marks
+
+Lilypond [shorthand articulation marks](http://www.lilypond.org/doc/v2.18/Documentation/notation/expressive-marks-attached-to-notes#articulations-and-ornamentations) can be entered after a backslash
+
+    c\^ e\+ g\_ => c-^ e-+ g-_
+
+Common articulation marks can be entered immediately after the note:
+
+    // tenuto, staccato, staccatissimo
+    c_e.g` => c-- e-. g-!
+
+Other arbitrary lilypond articulations can be entered after a backslash:
+
+    c\staccato e\mordent g\turn => c\staccato e\mordent g\turn
+
+[Dynamic marks](http://www.lilypond.org/doc/v2.18/Documentation/notation/expressive-marks-attached-to-notes#dynamics) are entered before the note to which they apply:
+
+    c\f eg
+
+    \f cege \p cfaf => c\f e g e c\p f a f
+
+Arbitrary expression marks can be entered as a string following a backslash (for placing it under the note) or a forward slash (for placing it above the note).
+
+### Repeated articulation and rhythmic patterns: macros
+
+An important feature of lydown is the macro, which facilitates rapid entry of repeated rhythmic and articulative patterns.
+
+A common scenario is repeated articulation, for example a sequence of staccato notes:
+
+    {.}cdefgabc => c-. d-. e-. f-. g-. a-. b-. c-.
+
+A macro can also contain a fully qualified lilypond articulation specifier:
+
+    {\tenuto}cege => c\tenuto e\tenuto g\tenuto e\tenuto
+
+Rhythmic macros can be used for repeated rhythmic patterns. A common scenario is a dotted rhythm:
+
+    // The _ symbol denotes a note placeholder
+    {8._6_}cdefgfed => c8. d16 e8. f16 g8. f16 e8. d16
+
+A repeating diminution may also be expressed succintly:
+
+    // The @ symbol denotes a repeated pitch
+    {16_@@@}cfgf => c16 c c c f f f f g g g g f f f f
+
+A macro can include both durations and articulation marks:
+
+    {4_~6@(_._._.)}cdefgfed => c4 ~ c16 d-.( e-. f-.) g4 ~ g16 f-.( e-. d-.)
+
+A macro containing durations will remain valid until another duration or duration macro is encountered. A macro containing articulation only will be valid until another duration, macro or empty macro is encountered:
+
+    6{.}gg{}aa => g16-. g-. a a
+
+### Named macros
+
+Macros can be defined with a name and reused:
+
+    - macros:
+      - dotted: 8._6_
+    {dotted}gaba2g{dotted}abcb2a => g8. a16 b8. a16 g2 a8. b16 c8. b16 a2
+
+### Clefs, key and time signatures
+
+Clefs are determined automatically by lydown based on the specified part. In case no part is specified, the default clef is a treble clef. The clef values are the same as in [lilypond](http://www.lilypond.org/doc/v2.18/Documentation/notation/displaying-pitches#clef). The clef can be changed at any time with a clef setting:
+
+    - clef: bass
+    8cdefgabc
+    - clef: tenor
+    defedcbd
+    - clef: bass
+    1c
+
+Key and time signatures are entered inline as document settings ([see below](#settings)). The [key](http://www.lilypond.org/doc/v2.18/Documentation/notation/displaying-pitches#key-signature) and [time](http://www.lilypond.org/doc/v2.18/Documentation/notation/displaying-rhythms#time-signature) values follow the lilypond syntax:
+
+    - key: d major
+    - time: 3/4
+
+In the case of key signatures, accidentals will follow the lydown syntax:
+
+    - key: b- major
+    - key: f+ minor
+
+The default key signature is C major, and the default time signature is 4/4.
+
+Key or time signatures can be changed on the fly:
+
+    - time: 4/4
+    4c e g b
+    - time: 3/4
+    c e g 2.c
+
+### Pickup bars
+
+[Pickup bars](http://www.lilypond.org/doc/v2.18/Documentation/notation/displaying-rhythms#upbeats) (anacrusis, upbeat) are defined with the pickup setting:
+
+    - time: 3/4
+    - pickup: 4
+        4g
+    c8cdcb4aaa
+    d8dedc4bb
+
+### Inline lyrics
+
+Lyrics for vocal parts can be entered on separate lines prefixed by a > symbol:
+
+    4c[8de]4fd(4c[8de]2f)
+    > Ly-down is the bomb__
+
+Text alignment follows the duration, beaming and slurring of the music, just like in lilypond. Sillables are expected to be separated by a dash. Melismas, i.e. a single sillable streched over multiple notes, is signified by one or more underscores.
+
+### Stream switching
+
+Lyrics can be entered in a block, before or after musical notation, by switching streams:
+
+    8ccg'gaa4g
+    8ffeedd4c
+    =lyrics
+    Twin-kle twin-kle lit-tle star,
+    How I won-der what you are.
+    =music
+    8g'gffeed4
+    ...
+
+### Figured bass
+
+Figured bass is entered inline, following notes or even between notes, when
+multiple figures align with a single note.
+
+## Multiple parts
+
+Multiple parts can be entered in the same file by prefixing each part's content with a -part setting:
+
+    - part: violino1
+    8c'cg'gaa4g
+    - part: continuo
+    4cefe
+
+## Multiple movements
+
+For multi-movement works, prefix each movement with a -movement setting:
+
+    - movement: Adagio
+    ...
+    - movement: Allegro
+    ...
+
+## Multiple voices
+
+[Multiple voices](http://www.lilypond.org/doc/v2.18/Documentation/notation/multiple-voices#single_002dstaff-polyphony) on the same staff can be easily entered using the following notation:
+
+    1: 8egfdeg4f
+    2: 4cded
+
+## Piano scores
+
+[Piano/keyboard scores](http://www.lilypond.org/doc/v2.18/Documentation/notation/common-notation-for-keyboards) can be created by using the <code>r/l</code> (right/left) prefixes:
+
+    r: 8cdeccdec
+    l: 4cgcg
+
+In order to jump between staves, you can use the special commands <code>\r, \l</code>
+
+    r: 8<e'c'> \l g,f+g \r <g'' c'> \l e,,d+e \r
+    l: 1s
+
+## multi-part scores and part extraction
+
+As the example above shows, lydown supports multiple parts in the same file, but parts can also be written in separate files. This is useful for long pieces or those with a large number of parts.
+
+For this we create a main file which defines the score structure:
+
+// score.lydown
+- score:
+   - [violino1, violino2]
+   - viola
+   - violoncello
+- time: 4/4
+- key: c major
+
+Then we enter the music in a separate file for each part:
+
+// violino1.lydown
+8c''cg'gaa4g 8ffeedd4c
+
+And so forth.
+
+To compile the score, we use the following command:
+
+lydown -o -s score.lydown
+
+To extract a specific part, we use the -p  switch:
+
+lydown -o -p violino1 score.lydown
+
+## Adding a front cover
+
+When creating professional scores and parts, it is customary to add a cover page, with the title of the piece, the composer's name and other general information. Lydown includes a

data/bin/lydown

@@ -0,0 +1,149 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'lydown'
+require 'lydown/version'
+require 'optparse'
+
+trap("INT") {exit}
+trap("TERM") {exit}
+
+help = <<HELP
+Lydown is not lilypond
+HELP
+
+$options = {'format' => 'pdf'}
+opts = OptionParser.new do |opts|
+  opts.banner = help
+
+  opts.on("-v", "--version", "Display current version") do
+    puts "lydown " + Lydown::VERSION
+    exit 0
+  end
+  
+  opts.on("-p", "--parts PART", "Parts (comma-separated)") do |v|
+    $options["parts"] = v.split(',')
+  end
+  
+  opts.on("-m", "--mvts MVT", "Movements (comma-separated)") do |v|
+    $options["movements"] = v.split(',')
+  end
+  
+  opts.on("--no-score", "Do not generate secore") do
+    $options["no_score"] = true
+  end
+  
+  opts.on("-s", "--score", "Generate only score, no parts") do
+    $options["score_only"] = true
+  end
+  
+  opts.on("-V", "--vocal", "Generate only vocal score") do
+    $options["vocal_only"] = true
+  end
+  
+  opts.on("--ly", "Generate Lilypond file") do
+    $options["format"] = 'ly'
+  end
+  
+  opts.on("--pdf", "Generate PDF file") do
+    $options["format"] = 'pdf'
+  end
+
+  opts.on("--png", "Generate PNG file") do
+    $options["format"] = 'png'
+  end
+
+  opts.on("-M", "--midi", "Generate midi file") do
+    $options["format"] = 'midi'
+    $options["score_only"] = true # implied
+  end
+  
+  opts.on("-O", "--open", "Open PDF/Midi file after processing") do
+    $options["open_target"] = true
+  end
+
+  opts.on("-o", "--output FILE", "Filename for output") do |v|
+    $options["output_filename"] = v
+  end
+
+  opts.on("-W", "--work", "Create new work") do
+    $options["gen"] = :work
+  end
+end
+
+opts.parse!
+
+if $options["gen"]
+  # Ripple.generate($options["gen"], ARGV)
+  exit
+end
+
+source = ''
+if ARGV[0].nil? || ARGV[0] == '-'
+  # read source from stdin
+  source = STDIN.read
+  
+  # the output defaults to a file named lydown expect if the format is ly.
+  # In that case the output will be sent to STDOUT.
+  $options["output_filename"] ||= 'lydown' unless $options["format"] == 'ly'
+else
+  filename = ARGV[0]
+  $options['source_filename'] = filename
+  if (filename !~ /\.ld$/) and File.file?(filename + ".ld")
+    filename += ".ld"
+  end
+  
+  $options["output_filename"] ||= (filename =~ /^(.+)\.ld$/) ? $1 : filename
+end
+
+# translate lydown code to lilypond code
+ly = ''
+begin
+  work = Lydown::Work.new(path: $options['source_filename'], nice_error: true)
+  # work.process(lydown)
+  ly = work.to_lilypond(mode: :score)
+rescue LydownError => e
+  STDERR.puts e.message
+  exit 1
+rescue => e
+  STDERR.puts "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+  exit 1
+end
+
+if $options['format'] == 'ly'
+  unless $options["output_filename"]
+    puts ly
+    exit
+  else
+    begin
+      File.open($options["output_filename"] + '.ly', 'w+') do |f|
+        f.write ly
+      end
+      exit
+    rescue => e
+      STDERR.puts "#{e.class}: #{e.message}"
+      exit 1
+    end
+  end
+end
+
+# compile lilypond code
+begin
+  opts = {
+    output_filename:  $options['output_filename'],
+    format:           $options['format'],
+    mode:             :score
+  }
+  Lydown::Lilypond.compile(ly, opts)
+rescue LydownError => e
+  STDERR.puts e.message
+  exit 1
+rescue => e
+  STDERR.puts "#{e.class}: #{e.message}"
+  exit 1
+end
+
+if $options['open_target']
+  filename = "#{$options['output_filename']}.#{$options['format']}"
+  system("open #{filename}")
+end

data/lib/lydown/core_ext.rb

@@ -0,0 +1,121 @@
+class Hash
+  # Merges self with another hash, recursively.
+  #
+  # This code was lovingly stolen from some random gem:
+  # http://gemjack.com/gems/tartan-0.1.1/classes/Hash.html
+  #
+  # Thanks to whoever made it.
+  def deep_merge(hash)
+    target = Marshal.load(Marshal.dump(self))
+    target.deep_merge!(hash)
+  end
+
+  def deep_merge!(hash)
+    hash.keys.each do |key|
+      if hash[key].is_a? Hash and self[key].is_a? Hash
+        self[key] = self[key].deep_merge!(hash[key])
+        next
+      end
+
+      self[key] = hash[key]
+    end
+
+    self.deep = true
+    self
+  end
+  
+  def deep_clone
+    dest = {}.deep!
+    each do |k, v|
+      dest[k] = case v
+      when Hash
+        v.deep_clone
+      when Array
+        v.clone
+      else
+        v
+      end
+    end
+    dest
+  end
+
+  def lookup(path)
+    path.split("/").inject(self) {|m,i| m[i].nil? ? (return nil) : m[i]}
+  end
+  
+  def set(path, value)
+    leafs = path.split("/")
+    k = leafs.pop
+    h = leafs.inject(self) {|m, i| m[i].is_a?(Hash) ? m[i] : (m[i] = {})}
+    h[k] = value
+  end
+  
+  attr_accessor :deep
+
+  alias_method :old_get, :[]
+  def [](k)
+    if @deep && k.is_a?(String) && k =~ /\//
+      lookup(k)
+    elsif @deep && k.is_a?(Symbol)
+      old_get(k.to_s)
+    else
+      old_get(k)
+    end
+  end
+  
+  alias_method :old_set, :[]=
+  def []=(k, v)
+    if @deep && k.is_a?(String) && k =~ /\//
+      set(k, v)
+    elsif @deep && k.is_a?(Symbol)
+      old_set(k.to_s, v)
+    else
+      old_set(k, v)
+    end
+  end
+  
+  alias_method :old_merge, :merge
+  def merge(hash)
+    if @deep || hash.deep
+      deep_merge(hash)
+    else
+      old_merge(hash)
+    end
+  end
+  
+  alias_method :old_merge!, :merge!
+  def merge!(hash)
+    if @deep || hash.deep
+      deep_merge!(hash)
+    else
+      old_merge!(hash)
+    end
+  end
+  
+  def deep!
+    @deep = true
+    self
+  end
+end
+
+class String
+  def titlize(all_capitals = false)
+    all_capitals ? 
+      self.gsub("-", " ").gsub(/\b('?[a-z])/) {$1.capitalize} :
+      self.gsub("-", " ").capitalize
+  end
+
+  def camelize
+    split('_').collect(&:capitalize).join
+  end
+end
+
+class Fixnum
+  ROMAN = %w[0 I II III IV V VI VII VIII IX X XI XII XIII XIV XV XVI XVII XVIII XIX
+    XX XXI XXII XXIII XXIV XXV XXVI XXVII XXVIII XXIX XXX]
+  
+  def to_roman
+    ROMAN[self]
+  end
+end
+

data/lib/lydown/errors.rb

@@ -0,0 +1,2 @@
+class LydownError < RuntimeError
+end

data/lib/lydown/lilypond.rb

@@ -0,0 +1,41 @@
+require 'lydown/errors'
+require 'tmpdir'
+
+module Lydown
+  module Lilypond
+    class << self
+      def tmpdir
+        @tmpdir ||= Dir.mktmpdir
+      end
+      
+      def compile(source, opts = {})
+        opts[:output_filename] ||= 'lydown'
+        
+        ly_path = File.join(tmpdir, File.basename(opts[:output_filename]))
+        File.open(ly_path, 'w+') do |f|
+          f << source
+        end
+        
+        # Run lilypond, pipe source into its STDIN, and capture its STDERR
+        cmd = 'lilypond -lERROR '
+        cmd << "-o #{File.dirname(opts[:output_filename])} "
+        cmd << "--#{opts[:format]} " if opts[:format]
+        # cmd << '-s - 2>&1'
+        cmd << "-s #{ly_path} 2>&1"
+        
+        err_info = ''
+        IO.popen(cmd, 'r+') do |f|
+          f.puts source
+          f.close_write
+          err_info = f.read
+          f.close
+        end
+        unless $?.success?
+          err_info = err_info.lines[0, 3].join
+          raise LydownError, "Lilypond compilation failed:\n#{err_info}"
+        end
+      end
+    end
+  end
+end
+