musa-dsl 0.14.16

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

@@ -0,0 +1,94 @@
+require 'forwardable'
+
+class Musa::Sequencer
+  extend Forwardable
+
+  def_delegators :@sequencer, :raw_at, :tick, :on_debug_at, :on_block_error
+  def_delegators :@sequencer, :on_fast_forward, :ticks_per_bar, :round, :position=, :size, :event_handler, :empty?
+
+  def_delegators :@context, :position, :log
+  def_delegators :@context, :with, :now, :at, :wait, :play, :every, :move
+  def_delegators :@context, :everying, :playing, :moving
+  def_delegators :@context, :launch, :on
+
+  def initialize(beats_per_bar, ticks_per_beat, sequencer: nil, do_log: nil, &block)
+    @sequencer ||= Musa::BaseSequencer.new beats_per_bar, ticks_per_beat, do_log: do_log
+    @context = DSLContext.new @sequencer
+
+    with &block if block
+  end
+
+  def reset
+    @sequencer.reset
+  end
+
+  class DSLContext
+    extend Forwardable
+
+    attr_reader :sequencer
+
+    def_delegators :@sequencer, :launch, :on,
+                   :position, :everying, :playing, :moving,
+                   :ticks_per_bar, :round, :log, :inspect
+
+    def initialize(sequencer)
+      @sequencer = sequencer
+    end
+
+    def with(*value_parameters, **key_parameters, &block)
+      block ||= proc {}
+
+      _as_context_run block, value_parameters, key_parameters
+    end
+
+    def now(*value_parameters, **key_parameters, &block)
+      block ||= proc {}
+
+      @sequencer.now *value_parameters, **key_parameters do |*value_args, **key_args|
+        _as_context_run block, value_args, key_args
+      end
+    end
+
+    def at(*value_parameters, **key_parameters, &block)
+      block ||= proc {}
+
+      @sequencer.at *value_parameters, **key_parameters do |*value_args, **key_args|
+        _as_context_run block, value_args, key_args
+      end
+    end
+
+    def wait(*value_parameters, **key_parameters, &block)
+      block ||= proc {}
+
+      @sequencer.wait *value_parameters, **key_parameters do | *values, **key_values |
+        _as_context_run block, values, key_values
+      end
+    end
+
+    def play(*value_parameters, **key_parameters, &block)
+      block ||= proc {}
+
+      @sequencer.play *value_parameters, **key_parameters do |*value_args, **key_args|
+        _as_context_run block, value_args, key_args
+      end
+    end
+
+    def every(*value_parameters, **key_parameters, &block)
+      block ||= proc {}
+
+      @sequencer.every *value_parameters, **key_parameters do |*value_args, **key_args|
+        _as_context_run block, value_args, KeyParametersProcedureBinder.new(block).apply(key_args)
+      end
+    end
+
+    def move(*value_parameters, **key_parameters, &block)
+      block ||= proc {}
+
+      @sequencer.move *value_parameters, **key_parameters do |*value_args, **key_args|
+        _as_context_run block, value_args, key_args
+      end
+    end
+  end
+
+  private_constant :DSLContext
+end

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

@@ -0,0 +1,3 @@
+require_relative 'base-sequencer-public'
+require_relative 'base-sequencer-implementation'
+require_relative 'sequencer-dsl'

data/lib/musa-dsl/sequencer.rb

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

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

@@ -0,0 +1,245 @@
+require 'musa-dsl/core-ext/duplicate'
+require 'musa-dsl/generative/generative-grammar'
+
+module Musa
+  module SerieOperations end
+
+  module SeriePrototyping
+    def prototype?
+      @is_instance ? false : true
+    end
+
+    def instance?
+      @is_instance ? true : false
+    end
+
+    def prototype
+      if @is_instance
+        @instance_of || (@instance_of = clone.tap(&:_prototype).mark_as_prototype!)
+      else
+        self
+      end
+    end
+
+    def _prototype
+      nil
+    end
+
+    alias_method :p, :prototype
+
+    def mark_as_prototype!
+      @is_instance = nil
+      freeze
+    end
+
+    protected :_prototype, :mark_as_prototype!
+
+    def mark_regarding!(source)
+      if source.prototype?
+        mark_as_prototype!
+      else
+        mark_as_instance!
+      end
+    end
+
+    protected :mark_regarding!
+
+    def instance
+      if @is_instance
+        self
+      else
+        clone(freeze: false).tap(&:_instance).mark_as_instance!(self)
+      end
+    end
+
+    alias_method :i, :instance
+
+    def _instance
+      nil
+    end
+
+    def mark_as_instance!(prototype = nil)
+      @instance_of = prototype
+      @is_instance = true
+      self
+    end
+
+    protected :_instance, :mark_as_instance!
+
+    class PrototypingSerieError < RuntimeError
+      def initialize(message = nil)
+        message ||= 'This serie is a prototype serie: cannot be consumed. To consume the serie use an instance serie via .instance method'
+        super message
+      end
+    end
+  end
+
+  module Serie
+    include SeriePrototyping
+    include SerieOperations
+
+    def restart
+      raise PrototypingSerieError unless @is_instance
+
+      @_have_peeked_next_value = false
+      @_peeked_next_value = nil
+      @_have_current_value = false
+      @_current_value = nil
+
+      _restart if respond_to? :_restart
+
+      self
+    end
+
+    def next_value
+      raise PrototypingSerieError unless @is_instance
+
+      unless @_have_current_value && @_current_value.nil?
+        if @_have_peeked_next_value
+          @_have_peeked_next_value = false
+          @_current_value = @_peeked_next_value
+        else
+          @_current_value = _next_value
+        end
+      end
+
+      propagate_value @_current_value
+
+      @_current_value
+    end
+
+    alias_method :v, :next_value
+
+    def peek_next_value
+      raise PrototypingSerieError unless @is_instance
+
+      unless @_have_peeked_next_value
+        @_have_peeked_next_value = true
+        @_peeked_next_value = _next_value
+      end
+
+      @_peeked_next_value
+    end
+
+    def current_value
+      raise PrototypingSerieError unless @is_instance
+
+      @_current_value
+    end
+
+    def infinite?
+      false
+    end
+
+    def to_a(recursive: nil, duplicate: nil, restart: nil, dr: nil)
+      recursive ||= false
+
+      dr ||= instance?
+
+      duplicate = dr if duplicate.nil?
+      restart = dr if restart.nil?
+
+      raise 'Cannot convert to array an infinite serie' if infinite?
+
+      array = []
+
+      serie = instance
+
+      serie = serie.duplicate if duplicate
+      serie = serie.restart if restart
+
+      while value = serie.next_value
+        array << if recursive
+                   process_for_to_a(value)
+                 else
+                   value
+                 end
+      end
+
+      array
+    end
+
+    alias_method :a, :to_a
+
+    def to_node(**attributes)
+      Nodificator.to_node(self, **attributes)
+    end
+
+    alias_method :node, :to_node
+
+    class Nodificator
+      extend Musa::GenerativeGrammar
+
+      def self.to_node(serie, **attributes)
+        N(serie, **attributes)
+      end
+    end
+
+    private_constant :Nodificator
+
+    protected
+
+    def propagate_value(value)
+      @_slaves.each { |s| s.push_next_value value } if @_slaves
+    end
+
+    private
+
+    def process_for_to_a(value)
+      case value
+      when Serie
+        value.to_a(recursive: true, restart: false, duplicate: false)
+      when Array
+        a = value.clone
+        a.collect! { |v| v.is_a?(Serie) ? v.to_a(recursive: true, restart: false, duplicate: false) : process_for_to_a(v) }
+      when Hash
+        h = value.clone
+        h.transform_values! { |v| v.is_a?(Serie) ? v.to_a(recursive: true, restart: false, duplicate: false) : process_for_to_a(v) }
+      else
+        value
+      end
+    end
+
+  end
+
+  class Slave
+    include Serie
+
+    attr_reader :master
+
+    def initialize(master)
+      @master = master
+      @next_value = []
+    end
+
+    def _restart
+      throw OperationNotAllowedError, "SlaveSerie #{self}: slave series cannot be restarted"
+    end
+
+    def next_value
+      value = @next_value.shift
+
+      raise "Warning: slave serie #{self} has lost sync with his master serie #{@master}" if value.nil? && !@master.peek_next_value.nil?
+
+      propagate_value value
+
+      value
+    end
+
+    def peek_next_value
+      value = @next_value.first
+
+      raise "Warning: slave serie #{self} has lost sync with his master serie #{@master}" if value.nil? && !@master.peek_next_value.nil?
+
+      value
+    end
+
+    def infinite?
+      @master.infinite?
+    end
+
+    def push_next_value(value)
+      @next_value << value
+    end
+  end
+end

data/lib/musa-dsl/series/hash-serie-splitter.rb

@@ -0,0 +1,194 @@
+module Musa
+  # TODO: adapt to series prototyping
+  # TODO: full test cases
+
+  module SerieOperations
+    def split(buffered: nil, master: nil)
+      buffered ||= false
+
+      return HashSplitter.new HashSplitter::KeyProxy.new(self) if master.nil? && !buffered
+      return HashSplitter.new HashSplitter::MasterSlaveKeyProxy.new(self, master) if !master.nil? && !buffered
+      return HashSplitter.new HashSplitter::BufferedKeyProxy.new(self) if buffered
+    end
+
+    class HashSplitter
+      def initialize(proxy)
+        @proxy = proxy
+        @series = {}
+      end
+
+      def [](key)
+        serie = if @series.key? key
+                  @series[key]
+                else
+                  @series[key] = Splitted.new(@proxy, key: key)
+                end
+      end
+
+      class KeyProxy
+        def initialize(hash_serie)
+          @serie = hash_serie.instance
+          @values = {}
+        end
+
+        def restart
+          @serie.restart
+          @values = {}
+        end
+
+        def next_value(key)
+          return nil unless @values
+
+          value = @values[key]
+
+          if value.nil?
+            before_values = @values.collect { |k, v| [k, v] unless v.nil? }.compact.to_h
+
+            @values = @serie.next_value
+            value = @values[key] if @values
+
+            warn "Warning: splitted serie #{@serie} values #{before_values} are being lost" if !value.nil? && !before_values.empty?
+          end
+
+          @values[key] = nil if @values
+
+          value
+        end
+
+        def peek_next_value(key)
+          value = @values[key]
+
+          if value.nil?
+            peek_values = @serie.peek_next_value
+            value = peek_values[key] if peek_values
+          end
+
+          value
+        end
+      end
+
+      class BufferedKeyProxy
+        def initialize(hash_serie)
+          @serie = hash_serie.instance
+          @values = {}
+        end
+
+        def restart
+          @serie.restart
+          @values = {}
+        end
+
+        def next_value(key)
+          value = nil
+
+          if @values[key].nil? || @values[key].empty?
+            hash_value = @serie.next_value
+
+            if hash_value
+              hash_value.each do |k, v|
+                @values[k] = [] if @values[k].nil?
+                @values[k] << v
+              end
+            end
+          end
+
+          value = @values[key].shift if @values[key]
+
+          value
+        end
+
+        def peek_next_value(key)
+          value = nil
+
+          if @values[key] && !@values[key].empty?
+            value = @values[key].first
+          else
+            peek_values = @serie.peek_next_value
+            value = peek_values[key] if peek_values
+          end
+
+          value
+        end
+      end
+
+      class MasterSlaveKeyProxy
+        def initialize(hash_serie, master)
+          @serie = hash_serie.instance
+          @master = master
+          @values = {}
+          @values_counter = {}
+        end
+
+        def restart
+          @serie.restart
+          @values = {}
+          @values_counter = {}
+        end
+
+        def next_value(key)
+          return nil unless @values
+
+          value = @values[key]
+
+          if value.nil?
+            @values = @serie.next_value
+
+            value = @values[key] if @values
+
+            # warn "Info: splitted serie #{@serie} use count on next_value: #{@values_counter}"
+            @values_counter = {}
+          end
+
+          @values_counter[key] ||= 0
+          @values_counter[key] += 1
+
+          @values[key] = nil if key == @master && @values
+
+          value
+        end
+
+        def peek_next_value(key)
+          return nil unless @values
+
+          value = @values[key]
+
+          if value.nil?
+            peek_values = @serie.peek_next_value
+            value = peek_values[key] if peek_values
+          end
+
+          value
+        end
+      end
+
+      class Splitted
+        include Serie
+
+        def initialize(proxy, key:)
+          @proxy = proxy
+          @key = key
+
+          mark_as_instance!
+        end
+
+        def _prototype
+          raise PrototypingSerieError, 'Cannot get prototype of a splitted serie'
+        end
+
+        def _restart
+          @proxy.restart
+        end
+
+        def next_value
+          @proxy.next_value(@key)
+        end
+
+        def peek_next_value
+          @proxy.peek_next_value(@key)
+        end
+      end
+    end
+
+    private_constant :HashSplitter
+  end
+end

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

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