musa-dsl 0.14.31 → 0.21.4

data/lib/musa-dsl/transport/dummy-clock.rb

@@ -1,46 +1,48 @@
-require 'musa-dsl/transport/clock'
+require_relative 'clock'
 
 module Musa
-  class DummyClock < Clock
-    def initialize(ticks = nil, do_log: nil, &block)
-      do_log ||= false
+  module Clock
+    class DummyClock < Clock
+      def initialize(ticks = nil, do_log: nil, &block)
+        do_log ||= false
 
-      super()
+        super()
 
-      raise ArgumentError, 'Cannot initialize with ticks and block. You can only use one of the parameters.' if ticks && block
+        raise ArgumentError, 'Cannot initialize with ticks and block. You can only use one of the parameters.' if ticks && block
 
-      @ticks = ticks
-      @do_log = do_log
-      @block = block
-    end
+        @ticks = ticks
+        @do_log = do_log
+        @block = block
+      end
 
-    attr_accessor :block, :ticks
+      attr_accessor :block, :ticks
 
-    def run
-      @on_start.each(&:call)
-      @run = true
+      def run
+        @on_start.each(&:call)
+        @run = true
 
-      while @run && eval_condition
-        yield if block_given?
+        while @run && eval_condition
+          yield if block_given?
 
-        Thread.pass
-      end
+          Thread.pass
+        end
 
-      @on_stop.each(&:call)
-    end
+        @on_stop.each(&:call)
+      end
 
-    def terminate
-      @run = false
-    end
+      def terminate
+        @run = false
+      end
 
-    private
+      private
 
-    def eval_condition
-      if @ticks
-        @ticks -= 1
-        @ticks > 0
-      else
-        @block.call
+      def eval_condition
+        if @ticks
+          @ticks -= 1
+          @ticks > 0
+        else
+          @block.call
+        end
       end
     end
   end

data/lib/musa-dsl/transport/external-tick-clock.rb

@@ -1,31 +1,32 @@
-require 'musa-dsl/transport/clock'
-require 'nibbler'
+require_relative 'clock'
 
 module Musa
-  class ExternalTickClock < Clock
-    def initialize(do_log: nil)
-      do_log ||= false
+  module Clock
+    class ExternalTickClock < Clock
+      def initialize(do_log: nil)
+        do_log ||= false
 
-      super()
+        super()
 
-      @do_log = do_log
-    end
+        @do_log = do_log
+      end
 
-    def run(&block)
-      @on_start.each(&:call)
-      @run = true
-      @block = block
-    end
+      def run(&block)
+        @on_start.each(&:call)
+        @run = true
+        @block = block
+      end
 
-    def tick
-      if @run
-        @block.call if @block
+      def tick
+        if @run
+          @block.call if @block
+        end
       end
-    end
 
-    def terminate
-      @on_stop.each(&:call)
-      @run = false
+      def terminate
+        @on_stop.each(&:call)
+        @run = false
+      end
     end
   end
 end

data/lib/musa-dsl/transport/input-midi-clock.rb

@@ -1,123 +1,132 @@
-require 'musa-dsl/transport/clock'
+require_relative 'clock'
 require 'nibbler'
 
 module Musa
-  class InputMidiClock < Clock
-    def initialize(input, do_log: nil)
-      do_log ||= false
+  module Clock
+    class InputMidiClock < Clock
+      def initialize(input, logger: nil, do_log: nil)
+        do_log ||= false
 
-      super()
+        super()
 
-      @input = input
-      @do_log = do_log
+        @input = input
+        @logger = logger
 
-      @nibbler = Nibbler.new
-    end
+        if logger
+          @logger = logger
+        else
+          @logger = Musa::Logger::Logger.new
+          @logger.debug! if do_log
+        end
 
-    def run
-      @run = true
+        @nibbler = Nibbler.new
+      end
 
-      while @run
-        raw_messages = @input.gets
-        @input.buffer.clear
+      def run
+        @run = true
 
-        messages = []
-        stop_index = nil
+        while @run
+          raw_messages = @input.gets
+          @input.buffer.clear
 
-        raw_messages.each do |message|
-          mm = @nibbler.parse message[:data]
+          messages = []
+          stop_index = nil
 
-          if mm
-            if mm.is_a? Array
-              mm.each do |m|
-                stop_index = messages.size if m.name == 'Stop' && !stop_index
-                messages << m
+          raw_messages.each do |message|
+            mm = @nibbler.parse message[:data]
+
+            if mm
+              if mm.is_a? Array
+                mm.each do |m|
+                  stop_index = messages.size if m.name == 'Stop' && !stop_index
+                  messages << m
+                end
+              else
+                stop_index = messages.size if mm.name == 'Stop' && !stop_index
+                messages << mm
               end
-            else
-              stop_index = messages.size if mm.name == 'Stop' && !stop_index
-              messages << mm
             end
           end
-        end
 
-        @nibbler.processed.clear
-        @nibbler.rejected.clear
-        @nibbler.messages.clear
+          @nibbler.processed.clear
+          @nibbler.rejected.clear
+          @nibbler.messages.clear
 
-        size = messages.size
-        index = 0
-        while index < size
-          if index == stop_index && size >= index + 3 &&
-             messages[index + 1].name == 'Song Position Pointer' &&
-             messages[index + 2].name == 'Continue'
+          size = messages.size
+          index = 0
+          while index < size
+            if index == stop_index && size >= index + 3 &&
+                messages[index + 1].name == 'Song Position Pointer' &&
+                messages[index + 2].name == 'Continue'
 
-            warn 'InputMidiClock: processing Stop + Song Position Pointer + Continue...' if @do_log
+              @logger.debug('InputMidiClock') { 'processing Stop + Song Position Pointer + Continue...' }
 
-            process_start unless @started
+              process_start unless @started
 
-            process_message messages[index + 1] do
-              yield if block_given?
-            end
+              process_message messages[index + 1] do
+                yield if block_given?
+              end
 
-            index += 2
+              index += 2
 
-            warn 'InputMidiClock: processing Stop + Song Position Pointer + Continue... done' if @do_log
+              @logger.debug('InputMidiClock') { 'processing Stop + Song Position Pointer + Continue... done' }
 
-          else
-            process_message messages[index] do
-              yield if block_given?
+            else
+              process_message messages[index] do
+                yield if block_given?
+              end
             end
+
+            index += 1
           end
 
-          index += 1
+          Thread.pass
         end
-
-        Thread.pass
       end
-    end
 
-    def terminate
-      @run = false
-    end
+      def terminate
+        @run = false
+      end
 
-    private
+      private
 
-    def process_start
-      warn 'InputMidiClock: processing Start...' if @do_log
+      def process_start
+        @logger.debug('InputMidiClock') { 'processing Start...' }
 
-      @on_start.each(&:call)
-      @started = true
+        @on_start.each(&:call)
+        @started = true
 
-      warn 'InputMidiClock: processing Start... done' if @do_log
-    end
+        @logger.debug('InputMidiClock') { 'processing Start... done' }
+      end
 
-    def process_message(m)
-      case m.name
-      when 'Start'
-        process_start
+      def process_message(m)
+        case m.name
+        when 'Start'
+          process_start
 
-      when 'Stop'
-        warn 'InputMidiClock: processing Stop...' if @do_log
+        when 'Stop'
+          @logger.debug('InputMidiClock') { 'processing Stop...' }
 
-        @on_stop.each(&:call)
-        @started = false
+          @on_stop.each(&:call)
+          @started = false
 
-        warn 'InputMidiClock: processing Stop... done' if @do_log
+          @logger.debug('InputMidiClock') { 'processing Stop... done' }
 
-      when 'Continue'
-        warn 'InputMidiClock: processing Continue...' if @do_log
-        warn 'InputMidiClock: processing Continue... done' if @do_log
+        when 'Continue'
+          @logger.debug('InputMidiClock') { 'processing Continue...' }
+          @logger.debug('InputMidiClock') { 'processing Continue... done' }
 
-      when 'Clock'
-        yield if block_given? && @started
+        when 'Clock'
+          yield if block_given? && @started
 
-      when 'Song Position Pointer'
-        new_position_in_midi_beats =
-          m.data[0] & 0x7F | ((m.data[1] & 0x7F) << 7)
+        when 'Song Position Pointer'
+          new_position_in_midi_beats =
+              m.data[0] & 0x7F | ((m.data[1] & 0x7F) << 7)
 
-        warn "InputMidiClock: processing Song Position Pointer new_position_in_midi_beats #{new_position_in_midi_beats}..." if @do_log
-        @on_change_position.each { |block| block.call midi_beats: new_position_in_midi_beats }
-        warn "InputMidiClock: processing Song Position Pointer new_position_in_beats #{new_position_in_midi_beats}... done" if @do_log
+          @logger.debug('InputMidiClock') { "processing Song Position Pointer new_position_in_midi_beats #{new_position_in_midi_beats}..." }
+          @on_change_position.each { |block| block.call midi_beats: new_position_in_midi_beats }
+          @logger.debug('InputMidiClock') { "processing Song Position Pointer new_position_in_beats #{new_position_in_midi_beats}... done" }
+        end
       end
     end
   end

data/lib/musa-dsl/transport/timer-clock.rb

@@ -1,102 +1,103 @@
-require 'musa-dsl/transport/clock'
-require 'nibbler'
+require_relative 'clock'
 
 module Musa
-  class TimerClock < Clock
-    def initialize(period = nil, ticks_per_beat: nil, bpm: nil, correction: nil, do_log: nil)
-      do_log ||= false
+  module Clock
+    class TimerClock < Clock
+      def initialize(period = nil, ticks_per_beat: nil, bpm: nil, correction: nil, do_log: nil)
+        do_log ||= false
 
-      super()
+        super()
 
-      @correction = correction
+        @correction = correction
 
-      self.period = period if period
-      self.ticks_per_beat = ticks_per_beat if ticks_per_beat
-      self.bpm = bpm if bpm
+        self.period = period if period
+        self.ticks_per_beat = ticks_per_beat if ticks_per_beat
+        self.bpm = bpm if bpm
 
-      self.bpm ||= 120
-      self.ticks_per_beat ||= 24
+        self.bpm ||= 120
+        self.ticks_per_beat ||= 24
 
-      @started = false
-      @paused = false
+        @started = false
+        @paused = false
 
-      @do_log = do_log
-    end
+        @do_log = do_log
+      end
 
-    attr_reader :period, :ticks_per_beat, :bpm
+      attr_reader :period, :ticks_per_beat, :bpm
 
-    def period=(period_in_seconds)
-      @period = period_in_seconds.rationalize
-      @bpm = 60r / (@period * @ticks_per_beat) if @period && @ticks_per_beat
-      @timer.period = @period if @timer
-    end
+      def period=(period_in_seconds)
+        @period = period_in_seconds.rationalize
+        @bpm = 60r / (@period * @ticks_per_beat) if @period && @ticks_per_beat
+        @timer.period = @period if @timer
+      end
 
-    def ticks_per_beat=(ticks)
-      @ticks_per_beat = ticks.rationalize
-      @period = 60r / (@bpm * @ticks_per_beat) if @bpm && @ticks_per_beat
-      @timer.period = @period if @timer && @period
-    end
+      def ticks_per_beat=(ticks)
+        @ticks_per_beat = ticks.rationalize
+        @period = 60r / (@bpm * @ticks_per_beat) if @bpm && @ticks_per_beat
+        @timer.period = @period if @timer && @period
+      end
 
-    def bpm=(bpm)
-      @bpm =  bpm.rationalize
-      @period = 60r / (@bpm * @ticks_per_beat) if @bpm && @ticks_per_beat
-      @timer.period = @period if @timer && @period
-    end
+      def bpm=(bpm)
+        @bpm =  bpm.rationalize
+        @period = 60r / (@bpm * @ticks_per_beat) if @bpm && @ticks_per_beat
+        @timer.period = @period if @timer && @period
+      end
 
-    def started?
-      @started
-    end
+      def started?
+        @started
+      end
 
-    def paused?
-      @paused
-    end
+      def paused?
+        @paused
+      end
 
-    def run
-      @run = true
+      def run
+        @run = true
 
-      while @run
-        @timer = Timer.new(@period, correction: @correction, stop: true)
+        while @run
+          @timer = Timer.new(@period, correction: @correction, stop: true)
 
-        @timer.run do
-          yield if block_given?
+          @timer.run do
+            yield if block_given?
+          end
         end
       end
-    end
 
-    def start
-      unless @started
-        @on_start.each(&:call)
-        @started = true
-        @paused = false
-        @timer.continue
+      def start
+        unless @started
+          @on_start.each(&:call)
+          @started = true
+          @paused = false
+          @timer.continue
+        end
       end
-    end
 
-    def stop
-      if @started
-        @timer.stop
-        @started = false
-        @paused = false
-        @on_stop.each(&:call)
+      def stop
+        if @started
+          @timer.stop
+          @started = false
+          @paused = false
+          @on_stop.each(&:call)
+        end
       end
-    end
 
-    def pause
-      if @started && !@paused
-        @timer.stop
-        @paused = true
+      def pause
+        if @started && !@paused
+          @timer.stop
+          @paused = true
+        end
       end
-    end
 
-    def continue
-      if @started && @paused
-        @paused = false
-        @timer.continue
+      def continue
+        if @started && @paused
+          @paused = false
+          @timer.continue
+        end
       end
-    end
 
-    def terminate
-      @run = false
+      def terminate
+        @run = false
+      end
     end
   end
 end