musa-dsl 0.14.16

data/lib/musa-dsl/series/proxy-serie.rb

@@ -0,0 +1,69 @@
+module Musa
+  module Series
+    # TODO: adapt to series prototyping
+
+    def PROXY(serie = nil)
+      ProxySerie.new(serie)
+    end
+
+    class ProxySerie
+      include Serie
+
+      attr_reader :target
+
+      def initialize(serie)
+        @target = serie.instance if serie
+        mark_as_instance!
+      end
+
+      def target=(target)
+        @target = target.instance
+      end
+
+      def _prototype
+        raise PrototypingSerieError, 'Cannot get prototype of a proxy serie'
+      end
+
+      def restart
+        @target.restart if @target
+      end
+
+      def current_value
+        @target.current_value if @target
+      end
+
+      def next_value
+        @target.next_value if @target
+      end
+
+      def peek_next_value
+        @target.peek_next_value if @target
+      end
+
+      def infinite?
+        @target.infinite? if @target
+      end
+
+      private
+
+      def method_missing(method_name, *args, **key_args, &block)
+        if @target && @target.respond_to?(method_name)
+          @target.send_nice method_name, *args, **key_args, &block
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private)
+        @target && @target.respond_to?(method_name, include_private) # || super
+      end
+    end
+  end
+
+  module SerieOperations
+    # TODO add test case
+    def proxied
+      Series::ProxySerie.new self
+    end
+  end
+end

data/lib/musa-dsl/series/queue-serie.rb

@@ -0,0 +1,94 @@
+module Musa
+  module Series
+    # TODO: adapt to series prototyping
+
+    def QUEUE(*series)
+      QueueSerie.new(series)
+    end
+
+    class QueueSerie
+      include Serie
+
+      attr_reader :targets, :target
+
+      def initialize(series)
+        @targets = series.collect(&:instance)
+        @targets ||= []
+
+        mark_as_instance!
+
+        _restart
+      end
+
+      def <<(serie)
+        @targets << serie.instance
+        check_current
+        self
+      end
+
+      def clear
+        @targets.clear
+        restart
+        self
+      end
+
+      def _prototype
+        raise PrototypingSerieError, 'Cannot get prototype of a proxy serie'
+      end
+
+      def _restart
+        @index = -1
+        forward
+      end
+
+      def _next_value
+        value = nil
+
+        if @target
+          value = @target.next_value
+
+          if value.nil?
+            forward
+            value = next_value
+          end
+        end
+
+        value
+      end
+
+      def infinite?
+        !!@targets.find(&:infinite?)
+      end
+
+      private
+
+      def forward
+        @index += 1
+        @target = nil
+        @target = @targets[@index].restart if @index < @targets.size
+      end
+
+      def check_current
+        @target = @targets[@index].restart unless @target
+      end
+
+      def method_missing(method_name, *args, **key_args, &block)
+        if @target && @target.respond_to?(method_name)
+          @target.send_nice method_name, *args, **key_args, &block
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private)
+        @target && @target.respond_to?(method_name, include_private) # || super
+      end
+    end
+  end
+
+  module SerieOperations
+    def queued
+      Series::QueueSerie.new [self]
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+require_relative 'base-series'
+
+require_relative 'main-serie-constructors'
+require_relative 'main-serie-operations'
+require_relative 'hash-serie-splitter'
+require_relative 'holder-serie'
+require_relative 'proxy-serie'
+require_relative 'queue-serie'

data/lib/musa-dsl/series.rb

@@ -0,0 +1 @@
+require 'musa-dsl/series/series'

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

@@ -0,0 +1,36 @@
+require 'nibbler'
+
+module Musa
+  class Clock
+    def initialize
+      @run = nil
+      @on_start = []
+      @on_stop = []
+      @on_song_position_pointer = []
+    end
+
+    def running?
+      @run
+    end
+
+    def on_start(&block)
+      @on_start << block
+    end
+
+    def on_stop(&block)
+      @on_stop << block
+    end
+
+    def on_song_position_pointer(&block)
+      @on_song_position_pointer << block
+    end
+
+    def run
+      raise NotImplementedError
+    end
+
+    def terminate
+      raise NotImplementedError
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'musa-dsl/transport/clock'
+
+module Musa
+  class DummyClock < Clock
+    def initialize(ticks = nil, do_log: nil, &block)
+      do_log ||= false
+
+      super()
+
+      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
+
+    attr_accessor :block, :ticks
+
+    def run
+      @on_start.each(&:call)
+      @run = true
+
+      while @run && eval_condition
+        yield if block_given?
+
+        Thread.pass
+      end
+
+      @on_stop.each(&:call)
+    end
+
+    def terminate
+      @run = false
+    end
+
+    private
+
+    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

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

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

@@ -0,0 +1,124 @@
+require 'musa-dsl/transport/clock'
+require 'nibbler'
+
+module Musa
+  class InputMidiClock < Clock
+    def initialize(input, do_log: nil)
+      do_log ||= false
+
+      super()
+
+      @input = input
+      @do_log = do_log
+
+      @nibbler = Nibbler.new
+    end
+
+    def run
+      @run = true
+
+      while @run
+        raw_messages = @input.gets
+        @input.buffer.clear
+
+        messages = []
+        stop_index = nil
+
+        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
+          end
+        end
+
+        @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'
+
+            warn 'InputMidiClock: processing Stop + Song Position Pointer + Continue...' if @do_log
+
+            process_start unless @started
+
+            process_message messages[index + 1] do
+              yield if block_given?
+            end
+
+            index += 2
+
+            warn 'InputMidiClock: processing Stop + Song Position Pointer + Continue... done' if @do_log
+
+          else
+            process_message messages[index] do
+              yield if block_given?
+            end
+          end
+
+          index += 1
+        end
+
+        Thread.pass
+      end
+    end
+
+    def terminate
+      @run = false
+    end
+
+    private
+
+    def process_start
+      warn 'InputMidiClock: processing Start...' if @do_log
+
+      @on_start.each(&:call)
+      @started = true
+
+      warn 'InputMidiClock: processing Start... done' if @do_log
+    end
+
+    def process_message(m)
+      case m.name
+      when 'Start'
+        process_start
+
+      when 'Stop'
+        warn 'InputMidiClock: processing Stop...' if @do_log
+
+        @on_stop.each(&:call)
+        @started = false
+
+        warn 'InputMidiClock: processing Stop... done' if @do_log
+
+      when 'Continue'
+        warn 'InputMidiClock: processing Continue...' if @do_log
+        warn 'InputMidiClock: processing Continue... done' if @do_log
+
+      when 'Clock'
+        yield if block_given? && @started
+
+      when 'Song Position Pointer'
+        midi_beat_position =
+          m.data[0] & 0x7F | ((m.data[1] & 0x7F) << 7)
+
+        warn "InputMidiClock: processing Song Position Pointer midi_beat_position #{midi_beat_position}..." if @do_log
+        @on_song_position_pointer.each { |block| block.call midi_beat_position }
+        warn "InputMidiClock: processing Song Position Pointer midi_beat_position #{midi_beat_position}... done" if @do_log
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+require 'musa-dsl/transport/clock'
+require 'nibbler'
+
+module Musa
+  class TimerClock < Clock
+    def initialize(period = nil, ticks_per_beat: nil, bpm: nil, correction: nil, do_log: nil)
+      do_log ||= false
+
+      super()
+
+      @correction = correction
+
+      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
+
+      @started = false
+      @paused = false
+
+      @do_log = do_log
+    end
+
+    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 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 started?
+      @started
+    end
+
+    def paused?
+      @paused
+    end
+
+    def run
+      @run = true
+
+      while @run
+        @timer = Timer.new(@period, correction: @correction, stop: true)
+
+        @timer.run do
+          yield if block_given?
+        end
+      end
+    end
+
+    def start
+      unless @started
+        @on_start.each(&:call)
+        @started = true
+        @paused = false
+        @timer.continue
+      end
+    end
+
+    def stop
+      if @started
+        @timer.stop
+        @started = false
+        @paused = false
+        @on_stop.each(&:call)
+      end
+    end
+
+    def pause
+      if @started && !@paused
+        @timer.stop
+        @paused = true
+      end
+    end
+
+    def continue
+      if @started && @paused
+        @paused = false
+        @timer.continue
+      end
+    end
+
+    def terminate
+      @run = false
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Musa
+  class Timer
+    attr_accessor :period
+
+    def initialize(period_in_seconds, correction: nil, stop: nil)
+      @period = period_in_seconds.rationalize
+      @correction = (correction || 0r).rationalize
+      @stop ||= false
+    end
+
+    def run
+      @thread = Thread.current
+
+      @next_moment = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      loop do
+        unless @stop
+          yield
+
+          @next_moment += @period
+          to_sleep = (@next_moment  + @correction) - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          sleep to_sleep if to_sleep > 0.0
+        end
+
+        sleep if @stop
+      end
+    end
+
+    def stop
+      @stop = true
+    end
+
+    def continue
+      @stop = false
+      @next_moment = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @thread.run
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+require 'musa-dsl/sequencer'
+
+require 'musa-dsl/core-ext/key-parameters-procedure-binder'
+
+module Musa
+  class Transport
+    attr_reader :sequencer
+
+    def initialize(clock,
+                   beats_per_bar = nil,
+                   ticks_per_beat = nil,
+                   before_begin: nil,
+                   on_start: nil,
+                   after_stop: nil,
+                   before_each_tick: nil,
+                   on_position_change: nil,
+                   do_log: nil)
+
+      beats_per_bar ||= 4
+      ticks_per_beat ||= 24
+      do_log ||= false
+
+      @clock = clock
+
+      @before_begin = []
+      @before_begin << KeyParametersProcedureBinder.new(before_begin) if before_begin
+
+      @on_start = []
+      @on_start << KeyParametersProcedureBinder.new(on_start) if on_start
+
+      @before_each_tick = []
+      @before_each_tick << KeyParametersProcedureBinder.new(before_each_tick) if before_each_tick
+
+      @on_position_change = []
+      @on_position_change << KeyParametersProcedureBinder.new(on_position_change) if on_position_change
+
+      @after_stop = []
+      @after_stop << KeyParametersProcedureBinder.new(after_stop) if after_stop
+
+      @do_log = do_log
+
+      @sequencer = Sequencer.new beats_per_bar, ticks_per_beat, do_log: @do_log
+
+      @clock.on_start do
+        do_on_start
+      end
+
+      @clock.on_stop do
+        do_stop
+      end
+
+      @clock.on_song_position_pointer do |midi_beat_position|
+        position = Rational(midi_beat_position, 4 * beats_per_bar) + 1
+        tick_before_position = position - Rational(1, beats_per_bar * ticks_per_beat)
+
+        warn "Transport: received message position change to #{position}" if @do_log
+
+        start_again_later = false
+
+        if @sequencer.position > tick_before_position
+          do_stop
+          start_again_later = true
+        end
+
+        warn "Transport: setting sequencer position #{tick_before_position}" if @do_log
+        @sequencer.position = tick_before_position
+
+        @sequencer.raw_at position, force_first: true do
+          @on_position_change.each { |block| block.call @sequencer }
+        end
+
+        do_on_start if start_again_later
+      end
+    end
+
+    def before_begin(&block)
+      @before_begin << KeyParametersProcedureBinder.new(block)
+    end
+
+    def on_start(&block)
+      @on_start << KeyParametersProcedureBinder.new(block)
+    end
+
+    def before_each_tick(&block)
+      @before_each_tick << KeyParametersProcedureBinder.new(block)
+    end
+
+    def after_stop(&block)
+      @after_stop << KeyParametersProcedureBinder.new(block)
+    end
+
+    def on_position_change(&block)
+      @on_position_change << KeyParametersProcedureBinder.new(block)
+    end
+
+    def start
+      do_before_begin unless @before_begin_already_done
+
+      @clock.run do
+        @before_begin_already_done = false
+        @before_each_tick.each { |block| block.call @sequencer }
+        @sequencer.tick
+      end
+    end
+
+    def stop
+      @clock.terminate
+    end
+
+    private
+
+    def do_before_begin
+      warn 'Transport: doing before_begin initialization...' unless @before_begin.empty? || !@do_log
+      @before_begin.each { |block| block.call @sequencer }
+      warn 'Transport: doing before_begin initialization... done' unless @before_begin.empty? || !@do_log
+    end
+
+    def do_on_start
+      warn 'Transport: starting...' unless @on_start.empty? || !@do_log
+      @on_start.each { |block| block.call @sequencer }
+      warn 'Transport: starting... done'  unless @on_start.empty? || !@do_log
+    end
+
+    def do_stop
+      warn 'Transport: stoping...' unless @after_stop.empty? || !@do_log
+      @after_stop.each { |block| block.call @sequencer }
+      warn 'Transport: stoping... done' unless @after_stop.empty? || !@do_log
+
+      warn 'Transport: resetting sequencer...' if @do_log
+      @sequencer.reset
+      warn 'Transport: resetting sequencer... done' if @do_log
+
+      do_before_begin
+      @before_begin_already_done = true
+    end
+  end
+end

data/lib/musa-dsl/transport.rb

@@ -0,0 +1,9 @@
+require 'musa-dsl/transport/transport'
+
+require 'musa-dsl/transport/timer'
+
+require 'musa-dsl/transport/input-midi-clock'
+require 'musa-dsl/transport/timer-clock'
+require 'musa-dsl/transport/dummy-clock'
+require 'musa-dsl/transport/external-tick-clock'
+