musicality 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2b88f653838ad19299cc067b8b849a521cf7ca95
-  data.tar.gz: 1be51ce70f8a1c873ef95cd7887d63db02f50ccf
+  metadata.gz: a6974b6669fd75f17166b07bf7a92e5e76298143
+  data.tar.gz: e8d4366d647aa439d3d63a93103578b355461292
 SHA512:
-  metadata.gz: f4c6cc3c5383cf641734519e7bdb32969426252914d74f80649bf2d01fdc697dda211d73b31040550918688eb998a033c634b5b5413737a653780948fc1f396e
-  data.tar.gz: 7b5be121f5efa1881a309dbcda6209718428ee2ab8ebf73593d3345724b18b9d1983e3c0af40161e752f8aa988343129c49d24a414880b661ba4c076ec5ca702
+  metadata.gz: 231e327998bfbb3320ced367f4f71694e15b48f10380c42e3788868678c1c6c69f63001b3e43b3231ae48ef566db62ab52580c45e9b67eebccfd6d1951f72d5b
+  data.tar.gz: 673824837e850617754f9ea648e135516c27300b68d8d57568cf53ab5cee539d883f43d354e24eb3c4eccacd426fac9a64559f72d1b81e236353f64d136fca97

data/ChangeLog.md

@@ -1,3 +1,8 @@
+### 0.6.0 / 2015-04-28
+* Add Score DSL
+* Add composition convenience methods `e`, `q`, and `dq` for generating eighth, quarter, and dotted quarter notes
+* Add part selection and titling to Lilypond score engraver
+
 ### 0.5.0 / 2015-04-27
 * Alter note syntax
  * shift articulation placement to after pitches

data/lib/musicality/composition/dsl/score_dsl.rb

@@ -0,0 +1,30 @@
+module Musicality
+
+class ScoreDSL
+  def self.load fname
+    include Musicality
+    include Pitches
+    include Articulations
+    include Meters
+    include Dynamics
+
+    dsl = ScoreDSL.new
+    dsl.instance_eval(File.read(fname), fname)
+    dsl
+  end
+
+  def initialize
+    @score = nil
+  end
+
+  def score start_meter, start_tempo, &block
+    @score = Score::Measured.new(start_meter,start_tempo)
+    @score.instance_eval(&block)
+  end
+
+  def score_yaml
+    @score.pack.to_yaml
+  end
+end
+
+end

data/lib/musicality/composition/dsl/score_methods.rb

@@ -0,0 +1,77 @@
+module Musicality
+
+class Score
+  def section title, &block
+    a = duration
+    self.instance_eval(&block)
+    b = duration
+    @sections[title] = a...b
+  end
+
+  def repeat arg
+    case arg
+    when Range
+      program.push arg
+    when String,Symbol
+      program.push @sections.fetch(arg)
+    else
+      raise ArgumentError, "Arg is not a Range, String, or Symbol"
+    end
+  end
+
+  DEFAULT_START_DYNAMIC = Dynamics::MF
+  def notes part_notes
+    raise ArgumentError, "No part notes given" if part_notes.empty?
+
+    durs = part_notes.values.map {|notes| notes.map {|n| n.duration }.inject(0,:+) }
+    durs_uniq = durs.uniq
+    raise DurationMismatchError, "New part note durations do not all match" if durs_uniq.size > 1
+    dur = durs_uniq.first
+    raise NonPositiveError, "Part note durations are not positive" if dur <= 0
+
+    a = self.duration
+    starting_part_dur = self.max_part_duration
+    part_notes.each do |part,notes|
+      unless parts.has_key? part
+        parts[part] = Part.new DEFAULT_START_DYNAMIC
+        if starting_part_dur > 0
+          parts[part].notes.push Note.new(starting_part_dur)
+        end
+      end
+      parts[part].notes += notes
+    end
+    (parts.keys - part_notes.keys).each do |part|
+      parts[part].notes.push Note.new(dur)
+    end
+
+    b = self.duration
+    program.push a...b
+    a...b    
+  end
+
+  def dynamic_change new_dynamic, transition_dur: 0, offset: 0
+    if transition_dur == 0
+      tempo_changes[self.duration + offset] = Change::Immediate.new(new_tempo)
+    else
+      tempo_changes[self.duration + offset] = Change::Gradual.linear(new_tempo, transition_dur)
+    end
+  end
+  
+  class TempoBased < Score
+    def tempo_change new_tempo, transition_dur: 0, offset: 0
+      if transition_dur == 0
+        tempo_changes[self.duration + offset] = Change::Immediate.new(new_tempo)
+      else
+        tempo_changes[self.duration + offset] = Change::Gradual.linear(new_tempo, transition_dur)
+      end
+    end
+  end
+  
+  class Measured < Score::TempoBased
+    def meter_change new_meter, offset: 0
+      meter_changes[self.duration + offset] = Change::Immediate.new(new_meter)
+    end
+  end
+end
+
+end

data/lib/musicality/composition/note_generation.rb

@@ -28,4 +28,19 @@ def make_notes rhythm, pitch_groups
 end
 module_function :make_notes
 
+def e(pitch_groups)
+  pitch_groups.map {|pg| Note.eighth(pg) }
+end
+module_function :e
+
+def q(pitch_groups)
+  pitch_groups.map {|pg| Note.quarter(pg) }
+end
+module_function :q
+
+def dq(pitch_groups)
+  pitch_groups.map {|pg| Note.dotted_quarter(pg) }
+end
+module_function :dq
+
 end

data/lib/musicality/errors.rb

@@ -9,4 +9,6 @@ module Musicality
   class NotValidError < StandardError; end
   class DomainError < StandardError; end
   class EmptyError < StandardError; end
+  class DurationMismatchError < StandardError; end
+
 end

data/lib/musicality/notation/model/score.rb

@@ -2,11 +2,14 @@ module Musicality
 
 class Score
   include Validatable
-  attr_accessor :parts, :program
+  attr_accessor :parts, :program, :title, :composer
   
-  def initialize parts: {}, program: []
+  def initialize parts: {}, program: [], title: nil, composer: nil, sections: {}
     @parts = parts
     @program = program
+    @title = title
+    @composer = composer
+    @sections = sections
     yield(self) if block_given?
   end
 
@@ -21,7 +24,7 @@ class Score
     return @parts == other.parts && @program == other.program
   end
   
-  def duration
+  def max_part_duration
     @parts.map {|name,part| part.duration }.max || 0.to_r
   end
   
@@ -31,17 +34,19 @@ class Score
   
   class Timed < Score
     def seconds_long
-      self.duration
+      max_part_duration
     end
+    alias duration seconds_long
   end
   
   class TempoBased < Score
     attr_accessor :start_tempo, :tempo_changes
 
-    def initialize start_tempo, tempo_changes: {}, parts: {}, program: []
+    # See Score#initialize for remaining kwargs
+    def initialize start_tempo, tempo_changes: {}, **kwargs
       @start_tempo = start_tempo
       @tempo_changes = tempo_changes
-      super(parts: parts, program: program)
+      super(**kwargs)
     end
     
     def check_methods
@@ -54,7 +59,7 @@ class Score
     end
     
     def notes_long
-      self.duration
+      max_part_duration
     end
     
     private
@@ -81,6 +86,7 @@ class Score
   # Tempo-based score without meter, bar lines, or fixed pulse (beat).
   # Offsets are note-based, and tempo values are in quarter-notes-per-minute.
   class Unmeasured < Score::TempoBased
+    alias duration notes_long
   end
   
   # Tempo-based score with meter, bar lines, and a fixed pulse (beat).
@@ -88,12 +94,12 @@ class Score
   class Measured < Score::TempoBased
     attr_accessor :start_meter, :meter_changes
     
-    def initialize start_meter, start_tempo, meter_changes: {}, tempo_changes: {}, parts: {}, program: []
+    # See Score::TempoBased#initialize for remaining kwargs
+    def initialize start_meter, start_tempo, meter_changes: {}, **kwargs
       @start_meter = start_meter
       @meter_changes = meter_changes
       
-      super(start_tempo, tempo_changes: tempo_changes,
-            program: program, parts: parts)
+      super(start_tempo, **kwargs)
     end
     
     def check_methods
@@ -129,6 +135,8 @@ class Score
       end
       return moff_prev + Rational(noff_end - noff_prev, mdur_prev)
     end
+
+    alias duration measures_long
     
     private
     

data/lib/musicality/notation/packing/score_packing.rb

@@ -7,67 +7,79 @@ class Score
     end
     
     def self.unpack packing
-      score = Score.unpack_common(packing)
-      new(parts: score.parts, program: score.program)
+      new(**Score.unpack_common(packing))
     end
   end
   
   class TempoBased < Score
     def pack
-      packed_tcs = Hash[ tempo_changes.map do |offset,change|
-        [offset,change.pack]
-      end ]
-      
       pack_common.merge("start_tempo" => @start_tempo,
-        "tempo_changes" => packed_tcs)
+        "tempo_changes" => pack_tempo_changes)
     end
     
+    def pack_tempo_changes
+      Hash[ tempo_changes.map do |offset,change|
+        [offset,change.pack]
+      end ]
+    end
+
+    def self.unpack_tempo_changes packing
+      Hash[ packing["tempo_changes"].map do |k,v|
+        [k, Change.unpack(v) ]
+      end ]
+    end
+
     def self.unpack packing
-      score = Score.unpack_common(packing)
-      
       unpacked_tcs = Hash[ packing["tempo_changes"].map do |k,v|
         [k, Change.unpack(v) ]
       end ]
-      
+
+      Score.unpack_common(packing)
       new(packing["start_tempo"],
         tempo_changes: unpacked_tcs,
-        program: score.program,
-        parts: score.parts
-      )
-    end    
+        **unpacked)
+    end
   end
   
   class Unmeasured < TempoBased
-    def pack
-      super()
-    end
-    
     def self.unpack packing
-      score = superclass.unpack(packing)
-      new(score.start_tempo, program: score.program,
-        tempo_changes: score.tempo_changes, parts: score.parts)
+      new(packing["start_tempo"],
+        tempo_changes: unpack_tempo_changes(packing),
+        **Score.unpack_common(packing))
     end
   end
   
   class Measured < TempoBased
     def pack
-      return super().merge("start_meter" => start_meter.to_s,
-        "meter_changes" => Hash[ meter_changes.map do |off,change|
-          [off,change.pack(:with => :to_s)]
-        end ]
-      )
+      return super().merge("start_meter" => pack_start_meter,
+        "meter_changes" => pack_meter_changes)
+    end
+
+    def pack_meter_changes
+      Hash[ meter_changes.map do |off,change|
+        [off,change.pack(:with => :to_s)]
+      end ]
+    end
+
+    def pack_start_meter
+      start_meter.to_s
     end
     
-    def self.unpack packing
-      score = superclass.unpack(packing)
-      unpacked_start_meter = Meter.parse(packing["start_meter"])
-      unpacked_mcs = Hash[ packing["meter_changes"].map do |off,p|
+    def self.unpack_meter_changes packing
+      Hash[ packing["meter_changes"].map do |off,p|
          [off, Change.unpack(p, :with => :to_meter) ]
       end ]
-      
-      new(unpacked_start_meter, score.start_tempo,
-          parts: score.parts, program: score.program,
-          meter_changes: unpacked_mcs, tempo_changes: score.tempo_changes)
+    end
+
+    def self.unpack_start_meter packing
+      Meter.parse(packing["start_meter"])
+    end
+
+    def self.unpack packing
+      new(unpack_start_meter(packing), packing["start_tempo"],
+        tempo_changes: unpack_tempo_changes(packing),
+        meter_changes: unpack_meter_changes(packing),
+        **Score.unpack_common(packing))
     end
   end
   
@@ -89,6 +101,8 @@ class Score
     { "type" => self.class.to_s.split("::")[-1],
       "program" => packed_prog,
       "parts" => packed_parts,
+      "title" => @title,
+      "composer" => @composer
     }
   end
   
@@ -98,9 +112,11 @@ class Score
     end ]
     unpacked_prog = packing["program"].map {|str| Segment.parse(str) }
     
-    new(program: unpacked_prog,
-      parts: unpacked_parts
-    )
+    { :program => unpacked_prog,
+      :parts => unpacked_parts,
+      :title => packing["title"],
+      :composer => packing["composer"]
+    }
   end    
 end
 

data/lib/musicality/printing/lilypond/score_engraver.rb

@@ -15,41 +15,68 @@ class ScoreEngraver
     end
 
     @parts = score.collated? ? score.parts : ScoreCollator.new(score).collate_parts
+    @title = score.title
+    @composer = score.composer
   end
 
-  def make_lilypond part_names = nil
-    part_names ||= @parts.keys
-    output = "\\version \"#{LILYPOND_VERSION}\"\n{\n  <<\n"
-    master = true
-    part_names.each do |part_name|
-      part = @parts[part_name]
-      
-      clef = ScoreEngraver.best_clef(part.notes)
-      output += "  \\new Staff {\n"
-      output += "    \\clef #{clef}\n"
-      if(master)
-        output += "    \\time #{@start_meter.to_lilypond}\n"
-      end
+  # Generate a Lilypond header for the score
+  def header
+    output = "\\version \"#{LILYPOND_VERSION}\"\n"
+    output += "\\header {\n"
+    if @title
+      output += "  title = \"#{@title}\"\n"
+    end
+    if @composer
+      output += "  composer = \"#{@composer}\"\n"
+    end
+    output += "}\n"
 
-      line = ""
-      part.notes.each_index do |i|
-        note = part.notes[i]
-        begin
-          str = note.to_lilypond
-        rescue UnsupportedDurationError => e
-          binding.pry
-        end
+    return output
+  end
 
-        if (line.size + str.size) > MAX_LINE_LEN
-          output += "    " + line
-          line = ""
-        end
-        line += str
+  # Generate a Lilypond staff for the given part
+  def staff part, part_title, master: false
+    clef = ScoreEngraver.best_clef(part.notes)
+    output = "  \\new Staff {\n"
+    output += "    \\set Staff.instrumentName = \\markup { \"#{part_title}\" }\n"
+    output += "    \\clef #{clef}\n"
+    if(master)
+      output += "    \\time #{@start_meter.to_lilypond}\n"
+    end
+
+    line = ""
+    part.notes.each_index do |i|
+      note = part.notes[i]
+      begin
+        str = note.to_lilypond + " "
+      rescue UnsupportedDurationError => e
+        binding.pry
       end
-      output += "    " + line
 
-      output += "  }\n"
-      
+      if (line.size + str.size) > MAX_LINE_LEN
+        output += "    " + line
+        line = ""
+      end
+      line += str
+    end
+    output += "    " + line
+
+    output += "  }\n"
+  end
+
+  # @param [Hash] part_names A hash for titling parts differently than their names
+  # @param [Array] selected_parts The names of parts selected for engraving
+  def make_lilypond selected_parts: @parts.keys, part_titles: {}
+    (selected_parts - part_titles.keys).each do |part_name|
+      part_titles[part_name] = part_name
+    end
+    output = header
+    output += "{\n  <<\n"
+    master = true
+    selected_parts.each do |part_name|
+      part = @parts[part_name]
+      part_title = part_titles[part_name]
+      output += staff part, part_title, master: master
       master = false if master
     end
     output += "  >>\n}\n"

data/lib/musicality/version.rb

@@ -1,3 +1,3 @@
 module Musicality
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

data/lib/musicality.rb

@@ -82,6 +82,9 @@ require 'musicality/composition/transposition'
 require 'musicality/composition/generation/counterpoint_generator'
 require 'musicality/composition/generation/random_rhythm_generator'
 
+require 'musicality/composition/dsl/score_methods'
+require 'musicality/composition/dsl/score_dsl'
+
 #
 # Performance
 #
@@ -104,6 +107,10 @@ require 'musicality/performance/midi/part_sequencer'
 require 'musicality/performance/midi/score_sequencer'
 require 'musicality/performance/midi/score_sequencing'
 
+#
+# Printing
+#
+
 require 'musicality/printing/lilypond/errors'
 require 'musicality/printing/lilypond/pitch_engraving'
 require 'musicality/printing/lilypond/note_engraving'

data/spec/notation/model/score_spec.rb

@@ -33,10 +33,10 @@ describe Score do
     end
   end
   
-  describe '#duration' do
+  describe '#max_part_duration' do
     context 'no parts' do
       it 'should return 0' do
-        Score.new.duration.should eq(0)
+        Score.new.max_part_duration.should eq(0)
       end
     end
     
@@ -44,7 +44,16 @@ describe Score do
       it 'should return the part duration' do
         Score.new(parts: {"part1" => Part.new(Dynamics::PP,
           notes: "/4 /4 /2 1".to_notes)
-        }).duration.should eq(2)
+        }).max_part_duration.should eq(2)
+      end
+    end
+
+    context 'two parts' do
+      it 'should return the part duration of the longer part' do
+        Score.new(parts: {"part1" => Part.new(Dynamics::PP,
+          notes: "/4 /4 /2 1".to_notes), "part2" => Part.new(Dynamics::MP,
+          notes: "4".to_notes)
+        }).max_part_duration.should eq(4)
       end
     end
   end

data/spec/notation/packing/score_packing_spec.rb

@@ -1,6 +1,9 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 measured_score = Score::Measured.new(FOUR_FOUR,120) do |s|
+  s.title = "The best song ever"
+  s.composer = "James T."
+
   s.meter_changes[1] = Change::Immediate.new(THREE_FOUR)
   s.meter_changes[7] = Change::Immediate.new(SIX_EIGHT)
   
@@ -28,11 +31,15 @@ end
 unmeasured_score = Score::Unmeasured.new(30) do |s|
   s.program = measured_score.program
   s.parts = measured_score.parts
+  s.title = measured_score.title
+  s.composer = measured_score.composer
 end
 
 timed_score = Score::Timed.new do |s|
   s.program = measured_score.program
   s.parts = measured_score.parts
+  s.title = measured_score.title
+  s.composer = measured_score.composer
 end
 
 [ measured_score, unmeasured_score, timed_score ].each do |score|
@@ -72,6 +79,16 @@ end
           @h['parts'][name].should eq packing
         end
       end
+
+      it 'should add title to packing' do
+        @h.should have_key "title"
+        @h["title"].should eq @score.title
+      end
+
+      it 'should add composer to packing' do
+        @h.should have_key "composer"
+        @h["composer"].should eq @score.composer
+      end
     end
     
     describe '.unpack' do
@@ -90,6 +107,14 @@ end
       it 'should successfuly unpack the program' do
         @score2.program.should eq @score.program
       end
+
+      it 'should successfuly unpack the title' do
+        @score2.title.should eq @score.title
+      end
+
+      it 'should successfuly unpack the composer' do
+        @score2.composer.should eq @score.composer
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: musicality
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - James Tunnell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-28 00:00:00.000000000 Z
+date: 2015-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -137,6 +137,8 @@ files:
 - examples/notation/song1.rb
 - examples/notation/song2.rb
 - lib/musicality.rb
+- lib/musicality/composition/dsl/score_dsl.rb
+- lib/musicality/composition/dsl/score_methods.rb
 - lib/musicality/composition/generation/counterpoint_generator.rb
 - lib/musicality/composition/generation/random_rhythm_generator.rb
 - lib/musicality/composition/model/pitch_class.rb