midilib 2.0.5 → 3.0.1

data/lib/midilib/mergesort.rb

@@ -0,0 +1,39 @@
+# This code was originally taken from
+# http://github.com/adamjmurray/cosy/blob/master/lib/cosy/helper/midi_file_renderer_helper.rb
+# with permission from Adam Murray, who originally suggested this fix.
+# See http://wiki.github.com/adamjmurray/cosy/midilib-notes for details.
+
+# A stable sorting algorithm that maintains the relative order of equal
+# elements.
+#
+# This code used to be in a new subclass of Array, but that started causing
+# problems in Ruby 3.0, apparently due to the return type of the `[]`
+# operator which was the parent Array class.
+#
+# This code borrowed from 'Moser' http://codesnippets.joyent.com/posts/show/1699
+def mergesort(arr, &cmp)
+  cmp = ->(a, b) { a <=> b } if cmp.nil?
+  if arr.size <= 1
+    arr.dup
+  else
+    halves = mergesort_split(arr).map { |half| mergesort(half, &cmp) }
+    mergesort_merge(*halves, &cmp)
+  end
+end
+
+def mergesort_split(arr)
+  n = (arr.length / 2).floor - 1
+  [arr[0..n], arr[n + 1..-1]]
+end
+
+def mergesort_merge(first, second, &predicate)
+  result = []
+  until first.empty? || second.empty?
+    result << if predicate.call(first.first, second.first) <= 0
+                first.shift
+              else
+                second.shift
+              end
+  end
+  result.concat(first).concat(second)
+end

data/lib/midilib/sequence.rb

@@ -1,12 +1,10 @@
-require 'midilib/io/seqreader'
-require 'midilib/io/seqwriter'
-require 'midilib/measure.rb'
+require_relative 'io/seqreader'
+require_relative 'io/seqwriter'
+require_relative 'measure'
 
 module MIDI
-
   # A MIDI::Sequence contains MIDI::Track objects.
   class Sequence
-
     include Enumerable
 
     UNNAMED = 'Unnamed Sequence'
@@ -43,13 +41,13 @@ module MIDI
     attr_accessor :writer_class
 
     def initialize
-      @tracks = Array.new()
+      @tracks = []
       @ppqn = 480
 
       # Time signature
-      @numer = 4		# Numer + denom = 4/4 time default
+      @numer = 4 # Numer + denom = 4/4 time default
       @denom = 2
-      @clocks = 24    # Bug fix  Nov 11, 2007 - this is not the same as ppqn!
+      @clocks = 24 # Bug fix  Nov 11, 2007 - this is not the same as ppqn!
       @qnotes = 8
 
       @reader_class = IO::SeqReader
@@ -67,24 +65,25 @@ module MIDI
     # Returns the song tempo in beats per minute.
     def beats_per_minute
       return DEFAULT_TEMPO if @tracks.nil? || @tracks.empty?
-      event = @tracks.first.events.detect { |e| e.kind_of?(MIDI::Tempo) }
-      return event ? (Tempo.mpq_to_bpm(event.tempo)) : DEFAULT_TEMPO
+
+      event = @tracks.first.events.detect { |e| e.is_a?(MIDI::Tempo) }
+      event ? Tempo.mpq_to_bpm(event.tempo) : DEFAULT_TEMPO
     end
-    alias_method :bpm, :beats_per_minute
-    alias_method :tempo, :beats_per_minute
+    alias bpm beats_per_minute
+    alias tempo beats_per_minute
 
     # Pulses (also called ticks) are the units of delta times and event
     # time_from_start values. This method converts a number of pulses to a
     # float value that is a time in seconds.
     def pulses_to_seconds(pulses)
-      (pulses.to_f / @ppqn.to_f / beats_per_minute()) * 60.0
+      (pulses.to_f / @ppqn.to_f / beats_per_minute) * 60.0
     end
 
     # Given a note length name like "whole", "dotted quarter", or "8th
     # triplet", return the length of that note in quarter notes as a delta
     # time.
     def note_to_delta(name)
-      return length_to_delta(note_to_length(name))
+      length_to_delta(note_to_length(name))
     end
 
     # Given a note length name like "whole", "dotted quarter", or "8th
@@ -99,55 +98,61 @@ module MIDI
     def note_to_length(name)
       name.strip!
       name =~ /^(dotted)?(.*?)(triplet)?$/
-      dotted, note_name, triplet = $1, $2, $3
+      dotted = Regexp.last_match(1)
+      note_name = Regexp.last_match(2)
+      triplet = Regexp.last_match(3)
       note_name.strip!
       mult = 1.0
       mult = 1.5 if dotted
       mult /= 3.0 if triplet
       len = NOTE_TO_LENGTH[note_name]
       raise "Sequence.note_to_length: \"#{note_name}\" not understood in \"#{name}\"" unless len
-      return len * mult
+
+      len * mult
     end
 
     # Translates +length+ (a multiple of a quarter note) into a delta time.
     # For example, 1 is a quarter note, 1.0/32.0 is a 32nd note, 1.5 is a
     # dotted quarter, etc. Be aware when using division; 1/32 is zero due to
     # integer mathematics and rounding. Use floating-point numbers like 1.0
-    # and 32.0. This method always returns an integer.
+    # and 32.0. This method always returns an integer by calling `.round` on
+    # the floating-point result.
     #
     # See also note_to_delta and note_to_length.
     def length_to_delta(length)
-      return (@ppqn * length).to_i
+      (@ppqn * length).round
     end
 
     # Returns the name of the first track (track zero). If there are no
     # tracks, returns UNNAMED.
     def name
       return UNNAMED if @tracks.empty?
-      return @tracks.first.name()
+
+      @tracks.first.name
     end
 
     # Hands the name to the first track. Does nothing if there are no tracks.
     def name=(name)
       return if @tracks.empty?
+
       @tracks.first.name = name
     end
 
     # Reads a MIDI stream.
-    def read(io, proc = nil)	# :yields: track, num_tracks, index
-      reader = @reader_class.new(self, block_given?() ? Proc.new() : proc)
+    def read(io, &block) # :yields: track, num_tracks, index
+      reader = @reader_class.new(self, &block)
       reader.read_from(io)
     end
 
-    # Writes to a MIDI stream.
-    def write(io, proc = nil)	# :yields: track, num_tracks, index
-      writer = @writer_class.new(self, block_given?() ? Proc.new() : proc)
+    # Writes to a MIDI stream. +midi_format+ defaults to 1.
+    def write(io, midi_format = 1, &block) # :yields: track, num_tracks, index
+      writer = @writer_class.new(self, midi_format, &block)
       writer.write_to(io)
     end
 
     # Iterates over the tracks.
-    def each			# :yields: track
-      @tracks.each { |track| yield track }
+    def each(&block) # :yields: track
+      @tracks.each(&block)
     end
 
     # Returns a Measures object, which is an array container for all measures
@@ -156,13 +161,13 @@ module MIDI
       # Collect time sig events and scan for last event time
       time_sigs = []
       max_pos = 0
-      @tracks.each  do |t|
+      @tracks.each do |t|
         t.each do |e|
-          time_sigs << e if e.kind_of?(MIDI::TimeSig)
+          time_sigs << e if e.is_a?(MIDI::TimeSig)
           max_pos = e.time_from_start if e.time_from_start > max_pos
         end
       end
-      time_sigs.sort { |x,y| x.time_from_start <=> y.time_from_start }
+      time_sigs.sort { |x, y| x.time_from_start <=> y.time_from_start }
 
       # Add a "fake" time sig event at the very last position of the sequence,
       # just to make sure the whole sequence is calculated.
@@ -172,7 +177,9 @@ module MIDI
 
       # Default to 4/4
       measure_length = @ppqn * 4
-      oldnumer, olddenom, oldbeats = 4, 2, 24
+      oldnumer = 4
+      olddenom = 2
+      oldbeats = 24
 
       measures = MIDI::Measures.new(max_pos, @ppqn)
       curr_pos = 0
@@ -186,11 +193,12 @@ module MIDI
           curr_meas_no += 1
           curr_pos += measure_length
         end
-        oldnumer, olddenom, oldbeats = te.numerator, te.denominator, te.metronome_ticks
+        oldnumer = te.numerator
+        olddenom = te.denominator
+        oldbeats = te.metronome_ticks
         measure_length = te.measure_duration(@ppqn)
       end
       measures
     end
-
   end
 end

data/lib/midilib/track.rb

@@ -1,47 +1,7 @@
-require 'midilib/event'
+require_relative 'event'
+require_relative 'mergesort'
 
 module MIDI
-
-  # This is taken from
-  # http://github.com/adamjmurray/cosy/blob/master/lib/cosy/helper/midi_file_renderer_helper.rb
-  # with permission from Adam Murray, who originally suggested this fix.
-  # See http://wiki.github.com/adamjmurray/cosy/midilib-notes for details.
-  # First we need to add some API infrastructure:
-  class MIDI::Array < ::Array
-    # This code borrowed from 'Moser' http://codesnippets.joyent.com/posts/show/1699
-
-    # A stable sorting algorithm that maintains the relative order of equal elements
-    def mergesort(&cmp)
-      if cmp == nil
-        cmp = lambda { |a, b| a <=> b }
-      end
-      if size <= 1
-        self.dup
-      else
-        halves = split.map { |half| half.mergesort(&cmp) }
-        merge(*halves, &cmp)
-      end
-    end
-
-    protected
-    def split
-      n = (length / 2).floor - 1
-      [self[0..n], self[n+1..-1]]
-    end
-
-    def merge(first, second, &predicate)
-      result = []
-      until first.empty? || second.empty?
-        if predicate.call(first.first, second.first) <= 0
-          result << first.shift
-        else
-          result << second.shift
-        end
-      end
-      result.concat(first).concat(second)
-    end
-  end
-
   # A Track is a list of events.
   #
   # When you modify the +events+ array, make sure to call recalc_times so
@@ -52,7 +12,6 @@ module MIDI
   # IO::SeqReader but is _not_ kept up to date by any other methods.
 
   class Track
-
     include Enumerable
 
     UNNAMED = 'Unnamed'
@@ -62,22 +21,23 @@ module MIDI
 
     def initialize(sequence)
       @sequence = sequence
-      @events = Array.new()
+      @events = []
 
       # Bitmask of all channels used. Set when track is read in from
       # a MIDI file.
       @channels_used = 0
+      @instrument = nil
     end
 
     # Return track name. If there is no name, return UNNAMED.
     def name
-      event = @events.detect { |e| e.kind_of?(MetaEvent) && e.meta_type == META_SEQ_NAME }
+      event = @events.detect { |e| e.is_a?(MetaEvent) && e.meta_type == META_SEQ_NAME }
       event ? event.data_as_str : UNNAMED
     end
 
     # Set track name. Replaces or creates a name meta-event.
     def name=(name)
-      event = @events.detect { |e| e.kind_of?(MetaEvent) && e.meta_type == META_SEQ_NAME }
+      event = @events.detect { |e| e.is_a?(MetaEvent) && e.meta_type == META_SEQ_NAME }
       if event
         event.data = name
       else
@@ -112,7 +72,7 @@ module MIDI
       recalc_times(0, list2)
       list = list1 + list2
       recalc_delta_from_times(0, list)
-      return list
+      list
     end
 
     # Quantize every event. length_or_note is either a length (1 = quarter,
@@ -134,9 +94,9 @@ module MIDI
 
     # Recalculate start times for all events in +list+ from starting_at to
     # end.
-    def recalc_times(starting_at=0, list=@events)
-      t = (starting_at == 0) ? 0 : list[starting_at - 1].time_from_start
-      list[starting_at .. -1].each do |e|
+    def recalc_times(starting_at = 0, list = @events)
+      t = starting_at == 0 ? 0 : list[starting_at - 1].time_from_start
+      list[starting_at..-1].each do |e|
         t += e.delta_time
         e.time_from_start = t
       end
@@ -146,24 +106,24 @@ module MIDI
     # from each event's time_from_start. This is useful, for example, when
     # merging two event lists. As a side-effect, elements from starting_at
     # are sorted by time_from_start.
-    def recalc_delta_from_times(starting_at=0, list=@events)
+    def recalc_delta_from_times(starting_at = 0, list = @events)
       prev_time_from_start = 0
       # We need to sort the sublist. sublist.sort! does not do what we want.
       # We call mergesort instead of Array.sort because sort is not stable
       # (it can mix up the order of events that have the same start time).
       # See http://wiki.github.com/adamjmurray/cosy/midilib-notes for details.
-      list[starting_at .. -1] = MIDI::Array.new(list[starting_at .. -1]).mergesort do |e1, e2|
+      list[starting_at..-1] = mergesort(list[starting_at..-1]) do |e1, e2|
         e1.time_from_start <=> e2.time_from_start
       end
-      list[starting_at .. -1].each do |e|
+      list[starting_at..-1].each do |e|
         e.delta_time = e.time_from_start - prev_time_from_start
         prev_time_from_start = e.time_from_start
       end
     end
 
     # Iterate over events.
-    def each			# :yields: event
-      @events.each { |event| yield event }
+    def each(&block) # :yields: event
+      @events.each(&block)
     end
 
     # Sort events by their time_from_start. After sorting,
@@ -173,7 +133,6 @@ module MIDI
     # Note: this method is redundant, since recalc_delta_from_times sorts
     # the events first. This method may go away in a future release, or at
     # least be aliased to recalc_delta_from_times.
-    alias_method :sort, :recalc_delta_from_times
+    alias sort recalc_delta_from_times
   end
-
 end

data/lib/midilib/utils.rb

@@ -1,18 +1,16 @@
 module MIDI
-
   # Utility methods.
   class Utils
-
     # MIDI note names. NOTE_NAMES[0] is 'C', NOTE_NAMES[1] is 'C#', etc.
     NOTE_NAMES = [
       'C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'
     ]
 
     # Given a MIDI note number, return the name and octave as a string.
-    def Utils.note_to_s(num)
+    def self.note_to_s(num)
       note = num % 12
       octave = num / 12
-      return "#{NOTE_NAMES[note]}#{octave - 1}"
+      "#{NOTE_NAMES[note]}#{octave - 1}"
     end
 
     # Given an integer, returns it as a variable length array of bytes (the
@@ -21,7 +19,7 @@ module MIDI
     # The converse operation--converting a var len into a number--requires
     # input from a stream of bytes. Therefore we don't supply it here. That is
     # a part of the MIDIFile class.
-    def Utils.as_var_len(val)
+    def self.as_var_len(val)
       buffer = []
       buffer << (val & 0x7f)
       val = (val >> 7)
@@ -29,8 +27,7 @@ module MIDI
         buffer << (0x80 + (val & 0x7f))
         val = (val >> 7)
       end
-      return buffer.reverse!
+      buffer.reverse!
     end
-
   end
 end

data/lib/midilib.rb

@@ -5,11 +5,11 @@
 #
 # See the README.rdoc file or http://midilib.rubyforge.org for details.
 
-require 'midilib/info'
-require 'midilib/sequence'
-require 'midilib/track'
-require 'midilib/io/seqreader'
-require 'midilib/io/seqwriter'
+require_relative 'midilib/info'
+require_relative 'midilib/sequence'
+require_relative 'midilib/track'
+require_relative 'midilib/io/seqreader'
+require_relative 'midilib/io/seqwriter'
 
 # --
 # consts.rb, utils.rb, and event.rb are included by these files.

data/test/event_equality.rb

@@ -5,77 +5,75 @@
 # classes. If someone disagrees, it would be trivial to move them there.
 
 module MIDI
-
   class Event
-    def ==(an_obj)
-      return an_obj.instance_of?(self.class) &&
-        @status == an_obj.status &&
-        @delta_time == an_obj.delta_time &&
-        @time_from_start == an_obj.time_from_start
+    def ==(other)
+      other.instance_of?(self.class) &&
+        @status == other.status &&
+        @delta_time == other.delta_time &&
+        @time_from_start == other.time_from_start
     end
   end
 
   class ChannelEvent
-    def ==(an_obj)
-      return super(an_obj) && @channel == an_obj.channel
+    def ==(other)
+      super(other) && @channel == other.channel
     end
   end
 
   class NoteEvent < ChannelEvent
-    def ==(an_obj)
-      return super(an_obj) &&
-        @note == an_obj.note && @velocity == an_obj.velocity
+    def ==(other)
+      super(other) &&
+        @note == other.note && @velocity == other.velocity
     end
   end
 
   class Controller < ChannelEvent
-    def ==(an_obj)
-      return super(an_obj) &&
-        @controller == an_obj.controller && @value == an_obj.value
+    def ==(other)
+      super(other) &&
+        @controller == other.controller && @value == other.value
     end
   end
 
   class ProgramChange < ChannelEvent
-    def ==(an_obj)
-      return super(an_obj) && @program == an_obj.program
+    def ==(other)
+      super(other) && @program == other.program
     end
   end
 
   class ChannelPressure < ChannelEvent
-    def ==(an_obj)
-      return super(an_obj) && @pressure == an_obj.pressure
+    def ==(other)
+      super(other) && @pressure == other.pressure
     end
   end
 
   class PitchBend < ChannelEvent
-    def ==(an_obj)
-      return super(an_obj) && @value == an_obj.value
+    def ==(other)
+      super(other) && @value == other.value
     end
   end
 
   class SystemExclusive < SystemCommon
-    def ==(an_obj)
-      return super(an_obj) && @data == an_obj.data
+    def ==(other)
+      super(other) && @data == other.data
     end
   end
 
   class SongPointer < SystemCommon
-    def ==(an_obj)
-      return super(an_obj) && @pointer == an_obj.pointer
+    def ==(other)
+      super(other) && @pointer == other.pointer
     end
   end
 
   class SongSelect < SystemCommon
-    def ==(an_obj)
-      return super(an_obj) && @song == an_obj.song
+    def ==(other)
+      super(other) && @song == other.song
     end
   end
 
   class MetaEvent < Event
-    def ==(an_obj)
-      return super(an_obj) && @meta_type == an_obj.meta_type &&
-        @data == an_obj.data
+    def ==(other)
+      super(other) && @meta_type == other.meta_type &&
+        @data == other.data
     end
   end
-
 end

data/test/test_event.rb

@@ -7,7 +7,6 @@ require 'test/unit'
 require 'midilib'
 
 class EventTester < Test::Unit::TestCase
-
   def test_note_on
     e = MIDI::NoteOn.new
     assert_equal(MIDI::NOTE_ON, e.status)
@@ -20,25 +19,25 @@ class EventTester < Test::Unit::TestCase
 
   def test_to_s
     e = MIDI::NoteOn.new
-    assert_equal("0: ch 00 on 40 40", e.to_s)
+    assert_equal('0: ch 00 on 40 40', e.to_s)
     e.print_decimal_numbers = true
-    assert_equal("0: ch 0 on 64 64", e.to_s)
+    assert_equal('0: ch 0 on 64 64', e.to_s)
     e.print_note_names = true
-    assert_equal("0: ch 0 on E4 64", e.to_s)
+    assert_equal('0: ch 0 on E4 64', e.to_s)
     e.print_decimal_numbers = false
-    assert_equal("0: ch 00 on E4 40", e.to_s)
+    assert_equal('0: ch 00 on E4 40', e.to_s)
   end
 
   def test_pitch_bend
     e = MIDI::PitchBend.new(0, 128)
     b = e.data_as_bytes
-    assert_equal(0, b[1])	# lsb, 7 bits
-    assert_equal(1, b[2])	# msb, 7 bits
+    assert_equal(0, b[1])       # lsb, 7 bits
+    assert_equal(1, b[2])       # msb, 7 bits
 
     e.value = (3 << 7) + 42
     b = e.data_as_bytes
-    assert_equal(42, b[1])	# lsb, 7 bits
-    assert_equal(3, b[2])	# msb, 7 bits
+    assert_equal(42, b[1])      # lsb, 7 bits
+    assert_equal(3, b[2])       # msb, 7 bits
   end
 
   def test_quantize_1
@@ -58,7 +57,7 @@ class EventTester < Test::Unit::TestCase
 
     # Test with quantize_to(6)
     [0, 0, 0, 6, 6, 6, 6, 6, 6, 12, 12, 12, 12, 12, 12,
-      18, 18, 18, 18, 18, 18, 24].each_with_index do |after, before|
+     18, 18, 18, 18, 18, 18, 24].each_with_index do |after, before|
       e.time_from_start = before
       e.quantize_to(6)
       assert_equal(after, e.time_from_start)
@@ -131,5 +130,4 @@ class EventTester < Test::Unit::TestCase
     assert_equal('foobar', e.data_as_str)
     assert_equal(foobar_as_array, e.data)
   end
-
 end