musicality 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b76956290ba2ff351587624b43db12c84fc99a5
-  data.tar.gz: 02460a5a7b390c335ffac5c8050b76bb280fd149
+  metadata.gz: a2ca1d5317ab9f47ee4a5a48391c529b6db3dc80
+  data.tar.gz: 61306cd02de6089beb8ebfd71617cefbafb7a1ee
 SHA512:
-  metadata.gz: ed2d94a4bd155e24a072481ed45027b362475c68628d41be6cf1e565e08636564fd71375f01936fbb74a7fe13dfcd5bcd22649117b76e5d179ffa83d19031d53
-  data.tar.gz: 05d65518d4f9d8abb5bda61490cdfa18d4458148648b46f6edc4ba518d10caaf6f12c9dea74522cc4615fd650441a0892e43057928d97b358dcdc2eacc6d540a
+  metadata.gz: 48c4022b31b8fede1ecf3ae7d8a0f5ee574d02cb7c46863e746d2df11ce0a5f7eec568df3180742202c2ae11d0885c34a8df07c68d43bf17aa1af13fbeecc001
+  data.tar.gz: f4ef016ba31054de3de408c1952e2e8d8319c7d09b6faa6dbd72d166636ac7a4fafa1c2e3ffbbf996d3edff397cdbf808d3406bdb62631994d8dc4a5100f3228

data/ChangeLog.md

@@ -1,3 +1,29 @@
+### 0.8.0 / 2016-01-01
+* Require ruby v2.0 or greater.
+* Remove Score::Unmeasured and change Score::Measured to Score::Tempo
+* Add more convenience methods for note creation, and alter their interface to take a variable number of args, each being interpreted as a pitch group (which may also be a single pitch)
+* Add back Score#title= and Score#composer= methods
+* Change score creation method ScoreDSL#score to ScoreDSL#tempo_score, and add ScoreDSL#score reader method to get the created score.
+* Add bin/lilify to convert score (in YAML format) to Lilypond format using the ScoreEngraver class.
+* Add Score::Tempo#to_lilypond
+* Make default behaviour in lilify to engrave all parts, unless --split option is used. Replaced partname/title pair args with plain part names.
+* Add Key class. Add start_key and key_changes to Score class.
+* Integrate start_key into Lilypond engraving. Add sharp pitch classes.
+* Revise note model (for notation) and note sequence model (for performance), including parsing, to use slur marks and articulation only. And there are no legato/slur links or articulations anymore.
+* Modify note model (again) to include marks for slur and triplet. Modify parsing, performance, and printing code accordingly.
+* MIDI performance changes to support the new note sequence model
+* Add Packable module to take care of packing and unpacking. Remove custom pack/unpack code.
+* Add Part#settings. Create settings classes for LilyPond and MIDI
+* Add Part#lilypond_settings in lilypond_settings.rb and Part#midi_settings in midi_settings.rb
+* Add support for non-realtime SUperCollider performance
+* Make dynamic levels increase exponentially, like 
+* In ScoreCollator#collate_changes, return new start value as well as dynamic changes, instead of always creating an initial immediate change
+* Add SynthDef class to be able to include SynthDefs in SuperCollider code
+* Add musicality project infrastructure
+* Make examples less vague
+* Add #to_osc for Score::Tempo and Score::Timed
+* In ScoreCollator, use entire score if score has no program segments
+
 ### 0.7.0 / 2015-04-28
 * Replace Score's title and composer accessors with dual-methods Score#title and Score#composer that can be used to get/set. This makes them useful in the DSL context.
 
@@ -12,7 +38,7 @@
  * disallow articulation and accent when pitches aren't present
  * do not provide syntax for targeted slur and legato links
 * Add *basic* support for Lilypond engraving (sheet music printing)
-* Add `#to_midi_seq` convenience method to `Timed` and `TempoBased` scores.
+* Add `#to_midi_seq` convenience method to timed and tempo-based scores.
 * Add some rudimentary composition features
  * `ScaleClass` class: contains a series of increasing pitch intervals. Can be realized as a scale given a starting pitch class.
  * `Scale` class: contains a starting pitch class, and a series of pitch intervals. Can be realized as a series of pitches given a starting octave.

data/README.md

@@ -20,16 +20,44 @@ Or install it yourself as:
 
 ## Basic Usage
 
-Raw notation objects can be created like this:
+To begin with, Musicality has a class to represent pitch:
+```ruby
+require 'musicality'
+middle_c = Musicality::Pitch.new(octave: 4, semitone: 0)
+puts middle_c.freq # => 261.625...
+
+not_quite_middle_c = Musicality::Pitch.new(octave: 4, semitone: 0, cent: 12)
+puts not_quite_middle_c.freq # => 263.445...
+```
+
+For convenience, there are Pitch objects for commonly used octave-semitone combinations:
+```ruby
+require 'musicality'
+include Musicality::Pitches
+
+c_scale = [C4,D4,E4,F4,G4,A4,B4,C4]
+freqs = c_scale.map {|p| p.freq }
+```
+
+Notes can be created like this:
 ```ruby
 require 'musicality'
 include Musicality
 include Pitches
-include Dynamics
 
+# convenience methods for common durations
 single = Note.quarter(Ab4)
 rest = Note.quarter
 chord = Note.whole([C3,E3,G3])
+
+# specific duration + articulation
+note = Note.new(Rational(7,8), Bb3, articulation: Articulations::STACCATO)
+puts note.to_s  # => "7/8Bb3."
+
+# magic!
+puts note.transpose(2).to_s  # => "7/8C4."
+
+# combine notes into a part
 part = Part.new(MP, notes:[single,rest,chord])
 ```
 
@@ -44,35 +72,66 @@ require 'musicality'
 include Musicality
 include Meters
 include Dynamics
+include Pitches
 
-twinkle = Score::Measured.new(TWO_FOUR, 120) do |s|
+score = Score::Tempo.new(FOUR_FOUR, 120, title: "Twinkle, Twinkle, Little Star") do |s|
   s.parts["rhand"] = Part.new(MF) do |p|
-    p.notes += ("/4C4 "*2 + "/4G4 "*2 +
-                "/4A4 "*2 + "/2G4").to_notes
+    a_notes = q(C4,C4,G4,G4,A4,A4) + h(G4) +
+              q(F4,F4,E4,E4,D4,D4) + h(C4)
+    b_notes = q(G4,G4,F4,F4,E4,E4) + h(D4)
+    p.notes += a_notes + b_notes
   end
+  
   s.parts["lhand"] = Part.new(MF) do |p|
-    p.notes += ("/2C3,E3,G3 "*2 + 
-                "/2F2,A2,C3 /2C3,E3,G3").to_notes
+    Cmaj = [C3,E3,G3]
+    Fmaj = [F2,A2,C3]
+    Gmaj = [G2,B2,D3]
+    
+    a_chords = h(Cmaj,Cmaj,Fmaj,Cmaj) + 
+               h(Fmaj,Cmaj,Gmaj,Cmaj)
+    b_chords = h(Cmaj,Fmaj,Cmaj,Gmaj)
+    p.notes += a_chords + b_chords
   end
+  
+  s.program.push 0...4
+  s.program.push 4...6
+  s.program.push 4...6
   s.program.push 0...4
 end
 ```
 
 ## MIDI Sequencing
 
-A score can be prepared for MIDI playback using the `ScoreSequencer` class or `#to_midi_seq` method. To continue the previous example,
+A score can be prepared for MIDI playback by converting it to a MIDI::Sequence object (see [midilib]( https://github.com/jimm/midilib )). This can be accomplished with the `ScoreSequencer` class or `Score#to_midi_seq` method. To continue the previous example,
 ```ruby
 TEMPO_SAMPLE_RATE = 500
 seq = twinkle.to_midi_seq TEMPO_SAMPLE_RATE
-File.open('twinkle.mid', 'wb'){ |fout| seq.write(fout) }
+File.open('twinkle.mid', 'wb'){ |f| seq.write(f) }
 ```
+
+## LilyPond Engraving
+
+A score can be prepared for engraving (fancy printing) by converting it to a string in LilyPond text format (see [lilypond.org](http://lilypond.org/)). This can be accomplished using the `ScoreEngraver` class or `Score#to_lilypond` method. Using the score from the above example,
+```ruby
+File.open('twinkle.ly','w'){|f| f.write(twinkle.to_lilypond) }
+```
+
+
+## SuperCollider Rendering
+
+A score can be prepared for rendering (as audio) by converting it to a raw OSC binary file, used for SuperCollider non-realtime rendering (see [SuperCollider homepage](https://supercollider.github.io/)). This can be accomplished using the `SuperCollider::Conductor` class or `Score#to_osc` method. Using the score from the above example,
+```ruby
+twinkle.to_osc('twinkle')
+```
+
+
 ## Score DSL
 
 The score DSL is an internal DSL (built on Ruby) that consists of a *score* block with additional blocks inside this to add sections, notes, and tempo/meter/dynamic changes.
 
 Here is an example of a score file.
 ```ruby
-measured_score FOUR_FOUR, 120 do
+tempo_score Meters::FOUR_FOUR, 120 do
   title "Twinkle, Twinkle, Little Star"
 
   Cmaj = [C3,E3,G3]
@@ -109,6 +168,90 @@ dsl = ScoreDSL.load 'twinkle.score'
 score = dsl.score
 ``` 
 
+
+## Musicality Projects
+
+To create a new project for working on Muscality scores, use the `musicality` command-line executable that is installed along with the gem.
+
+    $ musicality new my_scores
+
+This will create a directory (or fill an existing one) with three files:
+* *Gemfile* - a Bundler gem dependency file that lists the `musicality` gem
+* *Rakefile* - creates rake tasks for processing score files (files with a .score extension)
+* *config.yml* - customize project configuration options
+
+Also, a *scores* subdirectory is created as the default location to keep score files.
+
+Before processing any scores, run
+
+    $ bundle install
+
+To process score files, run rake with the desired target format. The scores will be converted into any intermediate formats as necessary. For example, to generate a PDF by LilyPond engraving, run
+
+    $ rake pdf
+
+This will generate a .pdf file for each score file. In addition, this would cause a chain of intermediate files to be created as well, as follows:
+
+    fname.score -> fname.yml -> fname.ly -> fname.pdf
+
+The supported final target formats are listed in the table below.
+
+<table>
+  <tr>
+    <th>Target format</th>
+    <th>Rake command</th>
+  </tr>
+  <tr>
+    <td>MIDI</td>
+    <td>midi</td>
+  </tr>
+  <tr>
+    <td>LilyPond PDF</td>
+    <td>pdf</td>
+  </tr>
+  <tr>
+    <td>LilyPond PNG</td>
+    <td>png</td>
+  </tr>
+  <tr>
+    <td>LilyPond PostScript</td>
+    <td>ps</td>
+  </tr>
+  <tr>
+    <td>SuperCollider AIFF</td>
+    <td>aiff</td>
+  </tr>
+  <tr>
+    <td>SuperCollider WAV</td>
+    <td>wav</td>
+  </tr>
+  <tr>
+    <td>SuperCollider FLAC</td>
+    <td>flac</td>
+  </tr>
+</table>
+
+In addition, there are also commands for all the intermediate formats
+
+<table>
+  <tr>
+    <th>Target format</th>
+    <th>Rake command</th>
+  </tr>
+  <tr>
+    <td>YAML</td>
+    <td>yaml</td>
+  </tr>
+  <tr>
+    <td>LilyPond (text)</td>
+    <td>ly</td>
+  </tr>
+  <tr>
+    <td>Raw OSC (binary)</td>
+    <td>osc</td>
+  </tr>
+</table>
+
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/musicality/fork )

data/bin/collidify

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+
+exe_name = File.basename(__FILE__)
+
+doc = <<DOCOPT
+Loads a musicality score from YAML file, and generates SuperCollider code 
+for non-realtime SuperCollider rendering.
+
+If no part names are given, all score parts are selected for performance. 
+Otherwise, only the given parts names will be selected. If --outdir is not
+given, files will be put in the same directory as the score file.
+
+Usage:
+  #{exe_name} SCORE [PART]... [options]
+  #{exe_name} -h | --help
+  #{exe_name} --version
+
+Arguments:
+  SCORE A musicality score file (may be packed as a hash) in a YAML file
+  PART name of a part in the score (e.g. "lhand")
+  
+Options:
+   -v --verbose  Display sclang output
+  --outdir=OUTD  Dir where files will be put (defaults to same dir as score file)
+  --srate=SRATE  Sampling rate for converting tempo-based score to time-based
+                 score, and for sampling dynamic change values [default: 200]
+  --leadtime=LT  Time before performance begins (must be > 0) [default: 0.1]
+  -h --help      Show this screen.
+  --version      Show version.
+DOCOPT
+
+require 'docopt'
+begin
+  args = Docopt::docopt(doc)
+  puts args
+rescue Docopt::Exit => e
+  puts e.message
+  exit
+end
+
+require 'musicality'
+
+if args["--version"]
+  puts "#{exe_name} from musicality v#{Musicality::VERSION}"
+  exit
+end
+
+SCORE_FILE = args["SCORE"]
+unless File.exists? SCORE_FILE
+  puts "Score file #{SCORE_FILE} does not exist. Aborting."
+  exit
+end
+
+if args["--outdir"]
+  OUTDIR = args["--outdir"]
+  unless Dir.exists? OUTDIR
+    puts "Output directory #{OUTDIR} does not exist. Aborting."
+    exit
+  end
+else
+  OUTDIR = File.dirname(SCORE_FILE)
+end
+
+VERBOSE = args["--verbose"]
+PARTS = args["PART"]
+LEADTIME = args["--leadtime"].to_f
+
+require 'yaml'
+include Musicality
+
+File.open(SCORE_FILE) do |fin|
+  print "Reading file '#{SCORE_FILE}'..."
+  score = YAML.load(fin.read)
+  
+  if score.is_a? Hash
+    score = score.unpack
+  end
+  puts "done"
+
+  unless score.is_a? Score::Timed
+    print "Converting to timed score..."
+    score = score.to_timed(args["--srate"].to_i)
+    puts "done"
+  end
+  
+  if score.valid?
+    conductor = SuperCollider::Conductor.new(score)
+
+    perform_kwargs = { :verbose => VERBOSE, :lead_time => LEADTIME }
+    if PARTS.any?
+      perform_kwargs[:selected_parts] = PARTS
+    end
+    base_fpath = "#{OUTDIR}/#{File.basename(SCORE_FILE,File.extname(SCORE_FILE))}"
+
+    print "Making SuperCollider binary OSC file..."
+    conductor.perform(base_fpath, **perform_kwargs)
+    puts "done"
+  else
+    puts "Score is not valid. See errors:"
+    puts score.errors.join("\n")
+  end
+end

data/bin/lilify

@@ -3,24 +3,27 @@
 exe_name = File.basename(__FILE__)
 
 doc = <<DOCOPT
-Loads a musicality score from YAML file, and converts it to a Lilypond file for engraving.
+Loads a musicality score from YAML file, and converts it to one or more Lilypond 
+files for engraving. If no part names are given, all score parts are selected for
+engraving. Otherwise, only the given parts names will be selected. By default, a
+a single engraving file will be produced. If the --split flag is used, a file 
+will be produced for each part. If --outdir is not given, files will be put in
+the same directory as the score file.
 
 Usage:
-  #{exe_name} <input> [PART TITLE] ... [options]
+  #{exe_name} SCORE [PART]... [options]
   #{exe_name} -h | --help
   #{exe_name} --version
 
 Arguments:
-  input A musicality score file (may be packed as a hash) in YAML format
+  SCORE A musicality score file (may be packed as a hash) in a YAML file
   PART name of a part in the score (e.g. "lhand")
-  TITLE The title to give the part (e.g. "Left Hand")
   
 Options:
-  --all         Select all parts for engraving, and use part name as the title if not given
-  -h --help     Show this screen.
-  --version     Show version.
-  --outfile=OUTF Name of output Lilypond file
-
+  --split        Make separate Lilypond files for each part
+  --outdir=OUTD  Dir where files will be put (defaults to same dir as score file)
+  -h --help      Show this screen.
+  --version      Show version.
 DOCOPT
 
 require 'docopt'
@@ -39,43 +42,68 @@ if args["--version"]
   exit
 end
 
+SCORE_FILE = args["SCORE"]
+unless File.exists? SCORE_FILE
+  puts "Score file #{SCORE_FILE} does not exist. Aborting."
+  exit
+end
+
+if args["--outdir"]
+  OUTDIR = args["--outdir"]
+  unless Dir.exists? OUTDIR
+    puts "Output directory #{OUTDIR} does not exist. Aborting."
+    exit
+  end
+else
+  OUTDIR = File.dirname(SCORE_FILE)
+end
+
+PARTS = args["PART"]
+SPLIT = args["--split"]
+
 require 'yaml'
 include Musicality
 
-fin_name = args["<input>"]
-File.open(fin_name) do |fin|
-  print "Reading file '#{fin_name}'..."
+File.open(SCORE_FILE) do |fin|
+  print "Reading file '#{SCORE_FILE}'..."
   score = YAML.load(fin.read)
   
   if score.is_a? Hash
-    score = Score.unpack(score)
+    score = score.unpack
   end
   puts "done"
   
   if score.valid?
-    part_names = args["PART"]
-    part_titles = args["TITLE"]
-    name_title_map = 
-
-    make_lilypond_args = {
-      :part_titles => Hash[[part_names,part_titles].transpose] 
-    }
-    unless args["--all"]
-      make_lilypond_args[:selected_parts] = part_names
+    if PARTS.any?
+      selected_parts = PARTS
+    else
+      selected_parts = score.parts.keys
     end
 
     print "Making Lilypond instructions..."
     engraver = ScoreEngraver.new(score)
-    lilypond_text = engraver.make_lilypond(make_lilypond_args)
-    puts "done"
+    outfiles = {}
 
-    fout_name = args["--outfile"]
-    if fout_name.nil?
-      fout_name = "#{File.dirname(fin_name)}/#{File.basename(fin_name,File.extname(fin_name))}.ly"
+    if SPLIT
+      selected_parts.each do |selected_part|
+        outfiles[selected_part] = engraver.make_lilypond([selected_part])
+      end
+    else
+      outfiles[""] = engraver.make_lilypond(selected_parts)
     end
-    print "Writing Lilypond file '#{fout_name}'..."
-    File.write(fout_name, lilypond_text)
     puts "done"
+
+    base_fout_name = "#{OUTDIR}/#{File.basename(SCORE_FILE,File.extname(SCORE_FILE))}"
+    outfiles.each do |outfile, lilypond_text|
+      if outfile.empty?
+        fout_name = "#{base_fout_name}.ly"
+      else
+        fout_name = "#{base_fout_name}_#{outfile}.ly"
+      end
+      print "Writing Lilypond file '#{fout_name}'..."
+      File.write(fout_name, lilypond_text)
+      puts "done"
+    end
   else
     puts "Score is not valid. See errors:"
     puts score.errors.join("\n")