musa-dsl 0.14.32 → 0.21.0

data/lib/musa-dsl/logger.rb

@@ -0,0 +1 @@
+require_relative 'logger/logger'

data/lib/musa-dsl/logger/logger.rb

@@ -0,0 +1,31 @@
+require 'logger'
+
+module Musa; module Logger
+  class Logger < ::Logger
+    def initialize(sequencer: nil, position_format: nil)
+      super STDERR
+
+      @sequencer = sequencer
+      @position_format = position_format || 3.3
+
+      self.formatter = proc do |severity, time, progname, msg|
+        level = "[#{severity}]" unless severity == 'DEBUG'
+
+        if msg
+          position = if @sequencer
+                       integer_digits = @position_format.to_i
+                       decimal_digits = ((@position_format - integer_digits) * 10).round
+
+                       "%#{integer_digits + decimal_digits + 1}s: " % ("%.#{decimal_digits}f" % sequencer.position.to_f)
+                     end
+
+          progname = "[#{progname}]" if progname
+
+          "#{position}#{level}#{progname}#{msg}\n"
+        else
+          "\n"
+        end
+      end
+    end
+  end
+end; end

data/lib/musa-dsl/matrix.rb

@@ -0,0 +1 @@
+require_relative 'matrix/matrix'

data/lib/musa-dsl/matrix/matrix.rb

@@ -0,0 +1,210 @@
+require 'matrix'
+
+require_relative '../datasets/p'
+require_relative '../sequencer'
+
+module Musa
+  module Matrix
+    ## TODO should exist this module?
+  end
+
+  module Extension
+    module Matrix
+      refine Array do
+        def indexes_of_values
+          indexes = {}
+
+          size.times do |i|
+            indexes[self[i]] ||= []
+            indexes[self[i]] << i
+          end
+
+          indexes
+        end
+
+        def to_p(time_dimension, keep_time: nil)
+          condensed_matrices.collect { |m| m.to_p(time_dimension, keep_time: keep_time) }
+        end
+
+        def condensed_matrices
+          condensed = []
+
+          each do |other|
+            if condensed.empty?
+              condensed << other
+            else
+              done = false
+              condensed.each do |matrix|
+                if matrix._rows.first == other._rows.first
+                  other._rows.shift
+                  matrix._rows.prepend other._rows.shift until other._rows.empty?
+                  done = true
+
+                elsif matrix._rows.first == other._rows.last
+                  other._rows.pop
+                  matrix._rows.prepend other._rows.pop until other._rows.empty?
+                  done = true
+
+                elsif matrix._rows.last == other._rows.first
+                  other._rows.shift
+                  matrix._rows.append other._rows.shift until other._rows.empty?
+                  done = true
+
+                elsif matrix._rows.last == other._rows.last
+                  other._rows.pop
+                  matrix._rows.append other._rows.pop until other._rows.empty?
+                  done = true
+                end
+
+                break if done
+              end
+              condensed << other unless done
+            end
+          end
+
+          condensed
+        end
+      end
+
+      refine ::Matrix do
+        include Musa::Datasets
+
+        def to_p(time_dimension, keep_time: nil)
+
+          decompose(self.to_a, time_dimension).collect do |points|
+            line = []
+
+            start_point = points[0]
+            start_time = start_point[time_dimension]
+
+            line << start_point.tap { |_| _.delete_at(time_dimension) unless keep_time; _ }.extend(Datasets::V)
+
+            (1..points.size-1).each do |i|
+              end_point = points[i]
+
+              end_time = end_point[time_dimension]
+
+              line << end_time - start_time
+              line << end_point.tap { |_| _.delete_at(time_dimension) unless keep_time; _ }.extend(Datasets::V)
+
+              start_time = end_time
+            end
+
+            line.extend(Datasets::P)
+          end
+        end
+
+        def to_score(time_dimension,
+                     mapper: nil,
+                     score: nil,
+                     position: nil,
+                     sequencer: nil,
+                     beats_per_bar: nil, ticks_per_beat: nil,
+                     right_open: nil,
+                     do_log: nil,
+                     &block)
+
+          raise ArgumentError,
+                "'beats_per_bar' and 'ticks_per_beat' parameters should be both nil or both have values" \
+              unless beats_per_bar && ticks_per_beat ||
+                     beats_per_bar.nil? && ticks_per_beat.nil?
+
+          raise ArgumentError,
+                "'sequencer' parameter should not be used when 'beats_per_bar' and 'ticks_per_beat' parameters are used" \
+            if sequencer && beats_per_bar
+
+          raise ArgumentError,
+                "'time_dimension' parameter should be an index number if no 'mapping' is provided" \
+            unless time_dimension.is_a?(Symbol) && mapper&.include?(time_dimension) ||
+                   time_dimension.is_a?(Integer) && (0..self.column_size-1).include(time_dimension)
+
+          time_dimension = mapper&.find_index(time_dimension) if time_dimension.is_a?(Symbol)
+
+          mapper = mapper.clone.tap { |_| _.delete_at(time_dimension) } if mapper
+
+          run_sequencer = sequencer.nil?
+
+          score ||= Musa::Datasets::Score.new
+
+          sequencer ||= Sequencer::Sequencer.new(beats_per_bar, ticks_per_beat, do_log: do_log)
+
+          right_open = right_open.clone.tap { |_| _.delete_at(time_dimension) } if right_open&.is_a?(Array)
+
+          sequencer.at(position || 1r) do |_|
+            to_p(time_dimension).each do |p|
+              p.to_score(score: score,
+                         mapper: mapper,
+                         sequencer: _,
+                         position: _.position,
+                         right_open: right_open,
+                         do_log: do_log,
+                         &block)
+            end
+          end
+
+          if run_sequencer
+            sequencer.run
+            score
+          else
+            nil
+          end
+        end
+
+        def _rows
+          @rows
+        end
+
+        private def decompose(array, time_dimension)
+          x_dim = array.collect { |v| v[time_dimension] }
+          x_dim_values_indexes = x_dim.indexes_of_values
+
+          used_indexes = Set[]
+
+          directional_segments = []
+
+          x_dim_values_indexes.keys.sort.each do |value|
+            x_dim_values_indexes[value].each do |index|
+              # hacia un lado
+
+              unless used_indexes.include?(index)
+                i = index
+                xx = array[i][time_dimension]
+
+                a = []
+
+                while i >= 0 && array[i][time_dimension] >= xx
+                  used_indexes << i
+                  a << array[i]
+
+                  xx = array[i][time_dimension]
+                  i -= 1
+                end
+
+                directional_segments << a if a.size > 1
+
+                # y hacia el otro
+
+                i = index
+                xx = array[i][time_dimension]
+
+                b = []
+
+                while i < array.size && array[i][time_dimension] >= xx
+                  used_indexes << i
+                  b << array[i]
+
+                  xx = array[i][time_dimension]
+                  i += 1
+                end
+
+                directional_segments << b if b.size > 1
+              end
+            end
+          end
+
+          return directional_segments
+        end
+      end
+    end
+  end
+end

data/lib/musa-dsl/midi.rb

@@ -1,2 +1,2 @@
-require 'musa-dsl/midi/midi-voices'
-require 'musa-dsl/midi/midi-recorder'
+require_relative 'midi/midi-voices'
+require_relative 'midi/midi-recorder'

data/lib/musa-dsl/midi/midi-recorder.rb

@@ -1,83 +1,85 @@
 require 'nibbler'
 
 module Musa
-  class MIDIRecorder
-    def initialize(sequencer)
-      @sequencer = sequencer
-      @nibbler = Nibbler.new
+  module MIDIRecorder
+    class MIDIRecorder
+      def initialize(sequencer)
+        @sequencer = sequencer
+        @nibbler = Nibbler.new
 
-      clear
-    end
+        clear
+      end
 
-    def clear
-      @messages = []
-    end
+      def clear
+        @messages = []
+      end
 
-    def record(midi_bytes)
-      m = @nibbler.parse midi_bytes
-      m = [m] unless m.is_a? Array
+      def record(midi_bytes)
+        m = @nibbler.parse midi_bytes
+        m = [m] unless m.is_a? Array
 
-      m.each do |mm|
-        @messages << Message.new(@sequencer.position, mm)
+        m.each do |mm|
+          @messages << Message.new(@sequencer.position, mm)
+        end
       end
-    end
 
-    def raw
-      @messages
-    end
+      def raw
+        @messages
+      end
 
-    def transcription
-      note_on = {}
-      last_note = {}
+      def transcription
+        note_on = {}
+        last_note = {}
 
-      notes = []
+        notes = []
 
-      @messages.each do |m|
-        mm = m.message
+        @messages.each do |m|
+          mm = m.message
 
-        if mm.is_a?(MIDIMessage::NoteOn)
+          if mm.is_a?(MIDIMessage::NoteOn)
 
-          if last_note[mm.channel]
-            notes << { position: last_note[mm.channel], channel: mm.channel, pitch: :silence, duration: m.position - last_note[mm.channel] }
-            last_note.delete mm.channel
-          end
+            if last_note[mm.channel]
+              notes << { position: last_note[mm.channel], channel: mm.channel, pitch: :silence, duration: m.position - last_note[mm.channel] }
+              last_note.delete mm.channel
+            end
 
-          note = { position: m.position, channel: mm.channel, pitch: mm.note, velocity: mm.velocity }
+            note = { position: m.position, channel: mm.channel, pitch: mm.note, velocity: mm.velocity }
 
-          note_on[mm.channel] ||= {}
-          note_on[mm.channel][mm.note] = note
+            note_on[mm.channel] ||= {}
+            note_on[mm.channel][mm.note] = note
 
-          notes << note
+            notes << note
 
-        elsif mm.is_a?(MIDIMessage::NoteOff)
+          elsif mm.is_a?(MIDIMessage::NoteOff)
 
-          note_on[mm.channel] ||= {}
+            note_on[mm.channel] ||= {}
 
-          note = note_on[mm.channel][mm.note]
+            note = note_on[mm.channel][mm.note]
 
-          if note
-            note_on[mm.channel].delete mm.note
+            if note
+              note_on[mm.channel].delete mm.note
 
-            note[:duration] = m.position - note[:position]
-            note[:velocity_off] = mm.velocity
-          end
+              note[:duration] = m.position - note[:position]
+              note[:velocity_off] = mm.velocity
+            end
 
-          last_note[mm.channel] = m.position
+            last_note[mm.channel] = m.position
+          end
         end
-      end
 
-      notes
-    end
+        notes
+      end
 
-    class Message
-      attr_accessor :position, :message
+      class Message
+        attr_accessor :position, :message
 
-      def initialize(position, message)
-        @position = position
-        @message = message
+        def initialize(position, message)
+          @position = position
+          @message = message
+        end
       end
-    end
 
-    private_constant :Message
+      private_constant :Message
+    end
   end
 end

data/lib/musa-dsl/midi/midi-voices.rb

@@ -1,274 +1,275 @@
 require 'set'
 require 'midi-message'
 
-require 'musa-dsl/core-ext/array-apply-get'
-require 'musa-dsl/core-ext/arrayfy'
+require_relative '../core-ext/arrayfy'
 
 module Musa
-  class MIDIVoices
-    attr_accessor :log
+  module MIDIVoices
+    class MIDIVoices
+      attr_accessor :log
 
-    def initialize(sequencer:, output:, channels:, do_log: nil)
-      do_log ||= false
+      def initialize(sequencer:, output:, channels:, do_log: nil)
+        do_log ||= false
 
-      @sequencer = sequencer
-      @output = output
-      @channels = channels.arrayfy.explode_ranges
-      @do_log = do_log
+        @sequencer = sequencer
+        @output = output
+        @channels = channels.arrayfy.explode_ranges
+        @do_log = do_log
 
-      reset
-    end
+        reset
+      end
 
-    def reset
-      @voices = @channels.collect { |channel| MIDIVoice.new sequencer: @sequencer, output: @output, channel: channel, log: @do_log }.freeze
-    end
+      def reset
+        @voices = @channels.collect { |channel| MIDIVoice.new sequencer: @sequencer, output: @output, channel: channel, log: @do_log }.freeze
+      end
 
-    attr_reader :voices
+      attr_reader :voices
 
-    def fast_forward=(enabled)
-      @voices.apply :fast_forward=, enabled
-    end
+      def fast_forward=(enabled)
+        @voices.each { |voice| voice.fast_forward = enabled }
+      end
 
-    def panic(reset: nil)
-      reset ||= false
+      def panic(reset: nil)
+        reset ||= false
 
-      @voices.each(&:all_notes_off)
+        @voices.each(&:all_notes_off)
 
-      @output.puts MIDIMessage::SystemRealtime.new(0xff) if reset
+        @output.puts MIDIMessage::SystemRealtime.new(0xff) if reset
+      end
     end
-  end
 
-  private
+    private
 
-  class MIDIVoice
-    attr_accessor :name, :do_log
-    attr_reader :sequencer, :output, :channel, :active_pitches, :tick_duration
+    class MIDIVoice
+      attr_accessor :name, :do_log
+      attr_reader :sequencer, :output, :channel, :active_pitches, :tick_duration
 
-    def initialize(sequencer:, output:, channel:, name: nil, log: nil)
-      log ||= false
+      def initialize(sequencer:, output:, channel:, name: nil, log: nil)
+        log ||= false
 
-      @sequencer = sequencer
-      @output = output
-      @channel = channel
-      @name = name
-      @do_log = log
+        @sequencer = sequencer
+        @output = output
+        @channel = channel
+        @name = name
+        @do_log = log
 
-      @tick_duration = Rational(1, @sequencer.ticks_per_bar)
+        @tick_duration = Rational(1, @sequencer.ticks_per_bar)
 
-      @controllers_control = ControllersControl.new(@output, @channel)
+        @controllers_control = ControllersControl.new(@output, @channel)
 
-      @active_pitches = []
-      fill_active_pitches @active_pitches
+        @active_pitches = []
+        fill_active_pitches @active_pitches
 
-      log 'Warning: voice without output' unless @output
+        log 'Warning: voice without output' unless @output
 
-      self
-    end
+        self
+      end
 
-    def fast_forward=(enabled)
-      if @fast_forward && !enabled
-        (0..127).each do |pitch|
-          @output.puts MIDIMessage::NoteOn.new(@channel, pitch, @active_pitches[pitch][:velocity]) unless @active_pitches[pitch][:note_controls].empty?
+      def fast_forward=(enabled)
+        if @fast_forward && !enabled
+          (0..127).each do |pitch|
+            @output.puts MIDIMessage::NoteOn.new(@channel, pitch, @active_pitches[pitch][:velocity]) unless @active_pitches[pitch][:note_controls].empty?
+          end
         end
-      end
 
-      @fast_forward = enabled
-    end
+        @fast_forward = enabled
+      end
 
-    def fast_forward?
-      @fast_forward
-    end
+      def fast_forward?
+        @fast_forward
+      end
 
-    def note(pitchvalue = nil, pitch: nil, velocity: nil, duration: nil, duration_offset: nil, effective_duration: nil, velocity_off: nil)
-      pitch ||= pitchvalue
+      def note(pitchvalue = nil, pitch: nil, velocity: nil, duration: nil, duration_offset: nil, note_duration: nil, velocity_off: nil)
+        pitch ||= pitchvalue
 
-      if pitch
-        velocity ||= 63
+        if pitch
+          velocity ||= 63
 
-        duration_offset ||= -@tick_duration
-        effective_duration ||= [0, duration + duration_offset].max
+          duration_offset ||= -@tick_duration
+          note_duration ||= [0, duration + duration_offset].max
 
-        velocity_off ||= 63
+          velocity_off ||= 63
 
-        NoteControl.new(self, pitch: pitch, velocity: velocity, duration: effective_duration, velocity_off: velocity_off).note_on
+          NoteControl.new(self, pitch: pitch, velocity: velocity, duration: note_duration, velocity_off: velocity_off).note_on
+        end
       end
-    end
 
-    def controller
-      @controllers_control
-    end
+      def controller
+        @controllers_control
+      end
 
-    def sustain_pedal=(value)
-      @controllers_control[:sustain_pedal] = value
-    end
+      def sustain_pedal=(value)
+        @controllers_control[:sustain_pedal] = value
+      end
 
-    def sustain_pedal
-      @controllers_control[:sustain_pedal]
-    end
+      def sustain_pedal
+        @controllers_control[:sustain_pedal]
+      end
 
-    def all_notes_off
-      @active_pitches.clear
-      fill_active_pitches @active_pitches
+      def all_notes_off
+        @active_pitches.clear
+        fill_active_pitches @active_pitches
 
-      @output.puts MIDIMessage::ChannelMessage.new(0xb, @channel, 0x7b, 0)
-    end
+        @output.puts MIDIMessage::ChannelMessage.new(0xb, @channel, 0x7b, 0)
+      end
 
-    def log(msg)
-      @sequencer.log "voice #{name || @channel}: #{msg}" if @do_log
-    end
+      def log(msg)
+        @sequencer.log "voice #{name || @channel}: #{msg}" if @do_log
+      end
 
-    def to_s
-      "voice #{@name} output: #{@output} channel: #{@channel}"
+      def to_s
+        "voice #{@name} output: #{@output} channel: #{@channel}"
       end
 
-    private
+      private
 
-    def fill_active_pitches(pitches)
-      (0..127).each do |pitch|
-        pitches[pitch] = { note_controls: Set[], velocity: 0 }
+      def fill_active_pitches(pitches)
+        (0..127).each do |pitch|
+          pitches[pitch] = { note_controls: Set[], velocity: 0 }
+        end
       end
-    end
 
-    class ControllersControl
-      def initialize(output, channel)
-        @output = output
-        @channel = channel
+      class ControllersControl
+        def initialize(output, channel)
+          @output = output
+          @channel = channel
 
-        @controller_map = { sustain_pedal: 0x40 }
-        @controller = []
-      end
+          @controller_map = { sustain_pedal: 0x40 }
+          @controller = []
+        end
 
-      def []=(controller_number_or_symbol, value)
-        number = number_of(controller_number_or_symbol)
-        value ||= 0
+        def []=(controller_number_or_symbol, value)
+          number = number_of(controller_number_or_symbol)
+          value ||= 0
 
-        @controller[number] = [[0, value].max, 0xff].min
-        @output.puts MIDIMessage::ChannelMessage.new(0xb, @channel, number, @controller[number])
-      end
+          @controller[number] = [[0, value].max, 0xff].min
+          @output.puts MIDIMessage::ChannelMessage.new(0xb, @channel, number, @controller[number])
+        end
 
-      def [](controller_number_or_symbol)
-        @controller[number_of(controller_number_or_symbol)]
-      end
+        def [](controller_number_or_symbol)
+          @controller[number_of(controller_number_or_symbol)]
+        end
 
-      def number_of(controller_number_or_symbol)
-        case controller_number_or_symbol
-        when Numeric
-          controller_number_or_symbol.to_i
-        when Symbol
-          @controller_map[controller_number_or_symbol]
-        else
-          raise ArgumentError, "#{controller_number_or_symbol} is not a Numeric nor a Symbol. Only MIDI controller numbers are allowed"
+        def number_of(controller_number_or_symbol)
+          case controller_number_or_symbol
+          when Numeric
+            controller_number_or_symbol.to_i
+          when Symbol
+            @controller_map[controller_number_or_symbol]
+          else
+            raise ArgumentError, "#{controller_number_or_symbol} is not a Numeric nor a Symbol. Only MIDI controller numbers are allowed"
+          end
         end
       end
-    end
 
-    private_constant :ControllersControl
+      private_constant :ControllersControl
 
-    class NoteControl
-      attr_reader :start_position, :end_position
+      class NoteControl
+        attr_reader :start_position, :end_position
 
-      def initialize(voice, pitch:, velocity: nil, duration: nil, velocity_off: nil)
-        raise ArgumentError, "MIDIVoice: note duration should be nil or Numeric: #{duration} (#{duration.class})" unless duration.nil? || duration.is_a?(Numeric)
+        def initialize(voice, pitch:, velocity: nil, duration: nil, velocity_off: nil)
+          raise ArgumentError, "MIDIVoice: note duration should be nil or Numeric: #{duration} (#{duration.class})" unless duration.nil? || duration.is_a?(Numeric)
 
-        @voice = voice
+          @voice = voice
 
-        @pitch = pitch.arrayfy.explode_ranges
+          @pitch = pitch.arrayfy.explode_ranges
 
-        @velocity = velocity.arrayfy.explode_ranges
-        @velocity_off = velocity_off.arrayfy.explode_ranges
+          @velocity = velocity.arrayfy.explode_ranges
+          @velocity_off = velocity_off.arrayfy.explode_ranges
 
-        @duration = duration
+          @duration = duration
 
-        @do_on_stop = []
-        @do_after = []
+          @do_on_stop = []
+          @do_after = []
 
-        @start_position = @end_position = nil
-      end
+          @start_position = @end_position = nil
+        end
 
-      def note_on
-        @start_position = @voice.sequencer.position
-        @end_position = nil
+        def note_on
+          @start_position = @voice.sequencer.position
+          @end_position = nil
 
-        @pitch.each_index do |i|
-          pitch = @pitch[i]
-          velocity = @velocity[i % @velocity.size]
+          @pitch.each_index do |i|
+            pitch = @pitch[i]
+            velocity = @velocity[i % @velocity.size]
 
-          if !silence?(pitch)
-            @voice.active_pitches[pitch][:note_controls] << self
-            @voice.active_pitches[pitch][:velocity] = velocity
+            if !silence?(pitch)
+              @voice.active_pitches[pitch][:note_controls] << self
+              @voice.active_pitches[pitch][:velocity] = velocity
 
-            msg = MIDIMessage::NoteOn.new(@voice.channel, pitch, velocity)
-            @voice.log "#{msg.verbose_name} velocity: #{velocity} duration: #{@duration}"
-            @voice.output.puts msg if @voice.output && !@voice.fast_forward?
-          else
-            @voice.log "silence duration: #{@duration}"
+              msg = MIDIMessage::NoteOn.new(@voice.channel, pitch, velocity)
+              @voice.log "#{msg.verbose_name} velocity: #{velocity} duration: #{@duration}"
+              @voice.output.puts msg if @voice.output && !@voice.fast_forward?
+            else
+              @voice.log "silence duration: #{@duration}"
+            end
           end
-        end
 
-        return self unless @duration
+          return self unless @duration
+
+          this = self
+          @voice.sequencer.wait @duration do
+            this.note_off velocity: @velocity_off
+          end
 
-        this = self
-        @voice.sequencer.wait @duration do
-          this.note_off velocity: @velocity_off
+          self
         end
 
-        self
-      end
+        def note_off(velocity: nil)
+          velocity ||= @velocity_off
 
-      def note_off(velocity: nil)
-        velocity ||= @velocity_off
+          velocity = velocity.arrayfy.explode_ranges
 
-        velocity = velocity.arrayfy.explode_ranges
+          @pitch.each_index do |i|
+            pitch = @pitch[i]
+            velocity_off = velocity[i % velocity.size]
 
-        @pitch.each_index do |i|
-          pitch = @pitch[i]
-          velocity_off = velocity[i % velocity.size]
+            next if silence?(pitch)
 
-          next if silence?(pitch)
+            @voice.active_pitches[pitch][:note_controls].delete self
 
-          @voice.active_pitches[pitch][:note_controls].delete self
+            next unless @voice.active_pitches[pitch][:note_controls].empty?
 
-          next unless @voice.active_pitches[pitch][:note_controls].empty?
+            msg = MIDIMessage::NoteOff.new(@voice.channel, pitch, velocity_off)
+            @voice.log msg.verbose_name.to_s
+            @voice.output.puts msg if @voice.output && !@voice.fast_forward?
+          end
 
-          msg = MIDIMessage::NoteOff.new(@voice.channel, pitch, velocity_off)
-          @voice.log msg.verbose_name.to_s
-          @voice.output.puts msg if @voice.output && !@voice.fast_forward?
-        end
+          @end_position = @voice.sequencer.position
 
-        @end_position = @voice.sequencer.position
+          @do_on_stop.each do |do_on_stop|
+            @voice.sequencer.wait 0, &do_on_stop
+          end
+
+          @do_after.each do |do_after|
+            @voice.sequencer.wait @voice.tick_duration + do_after[:bars], &do_after[:block]
+          end
 
-        @do_on_stop.each do |do_on_stop|
-          @voice.sequencer.wait 0, &do_on_stop
+          nil
         end
 
-        @do_after.each do |do_after|
-          @voice.sequencer.wait @voice.tick_duration + do_after[:bars], &do_after[:block]
+        def active?
+          @start_position && !@end_position
         end
 
-        nil
-      end
+        def on_stop(&block)
+          @do_on_stop << block
+          nil
+        end
 
-      def active?
-        @start_position && !@end_position
-      end
+        def after(bars = 0, &block)
+          @do_after << { bars: bars.rationalize, block: block }
+          nil
+        end
 
-      def on_stop(&block)
-        @do_on_stop << block
-        nil
-      end
+        private
 
-      def after(bars = 0, &block)
-        @do_after << { bars: bars.rationalize, block: block }
-        nil
+        def silence?(pitch)
+          pitch.nil? || pitch == :silence
+        end
       end
 
-      private
-
-      def silence?(pitch)
-        pitch.nil? || pitch == :silence
-      end
+      private_constant :NoteControl
     end
-
-    private_constant :NoteControl
   end
 end