musa-dsl 0.21.4 → 0.22.3

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

@@ -32,7 +32,7 @@ module Musa
         self
       end
 
-      def _prototype
+      def _prototype!
         raise PrototypingSerieError, 'Cannot get prototype of a proxy serie'
       end
 

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

@@ -2,9 +2,15 @@ require_relative 'base-series'
 
 require_relative 'main-serie-constructors'
 require_relative 'main-serie-operations'
-require_relative 'hash-serie-splitter'
+
+require_relative 'array-to-serie'
+
 require_relative 'holder-serie'
 require_relative 'proxy-serie'
 require_relative 'queue-serie'
 
-require_relative 'array-to-serie'
+require_relative 'hash-or-array-serie-splitter'
+
+require_relative 'quantizer-serie'
+require_relative 'flattener-timed-serie'
+require_relative 'union-timed-series'

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

@@ -0,0 +1,109 @@
+require_relative '../datasets/e'
+
+module Musa
+  module Series
+
+    extend self
+
+    def TIMED_UNION(*timed_series)
+      TimedUnion.new(timed_series)
+    end
+
+    class TimedUnion
+      include Serie
+
+      attr_reader :sources
+
+      def initialize(series)
+        @sources = if series[0].prototype?
+                     series.collect(&:prototype).freeze
+                   else
+                     series.collect(&:instance)
+                   end
+
+        _restart false
+
+        mark_regarding! series[0]
+      end
+
+      private def _restart(restart_sources = true)
+        @sources.each { |serie| serie.restart } if restart_sources
+        @sources_next_values = Array.new(@sources.size)
+
+        @components = nil
+        @hash_mode = @array_mode = nil
+      end
+
+      private def _next_value
+        sources_values = @sources_next_values.each_index.collect do |i|
+          @sources_next_values[i] || (@sources_next_values[i] = @sources[i].next_value)
+        end
+
+        infer_components(sources_values) if !@components
+
+        time = sources_values.collect { |_| _&.[](:time) }.compact.min
+
+        if time
+          selected_values = sources_values.collect { |_| _ if _&.[](:time) == time }
+
+          @sources_next_values.each_index do |i|
+            if @sources_next_values[i]&.[](:time) == time
+              @sources_next_values[i] = nil
+            end
+          end
+
+          if @hash_mode
+            result = {}
+          elsif @array_mode
+            result = []
+          else # value mode
+            result = []
+          end
+
+          @components.each do |target_key_or_index, source_placement|
+            result[target_key_or_index] = selected_values.dig(*source_placement)
+          end
+
+          { time: time,
+            value: result }
+        else
+          nil
+        end
+      end
+
+      def infinite?
+        !!@sources.find(&:infinite?)
+      end
+    end
+
+    private def infer_components(sources_values)
+      @components = {}
+      target_index = 0
+
+      sources_values.each_with_index do |source_value, i|
+        case source_value[:value]
+        when Hash
+          @hash_mode = true
+
+          source_value[:value].keys.each do |key|
+            @components[key] = [i, :value, key]
+          end
+        when Array
+          @array_mode = true
+
+          (0..source_value[:value].size - 1).each do |index|
+            @components[target_index] = [i, :value, index]
+            target_index += 1
+          end
+        else
+          @components[target_index] = [i, :value]
+          target_index += 1
+        end
+      end
+
+      raise RuntimeError, "source series values are of incompatible type (can't combine Hash and Array values)" if @array_mode && @hash_mode
+    end
+
+    private_constant :TimedUnion
+  end
+end

data/musa-dsl.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name        = 'musa-dsl'
-  s.version     = '0.21.4'
-  s.date        = '2020-10-20'
+  s.version     = '0.22.3'
+  s.date        = '2020-11-12'
   s.summary     = 'A simple Ruby DSL for making complex music'
   s.description = 'Musa-DSL: A Ruby DSL for algorithmic music composition, device language neutral (MIDI, OSC, etc)'
   s.authors     = ['Javier Sánchez Yeste']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: musa-dsl
 version: !ruby/object:Gem::Version
-  version: 0.21.4
+  version: 0.22.3
 platform: ruby
 authors:
 - Javier Sánchez Yeste
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-20 00:00:00.000000000 Z
+date: 2020-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: citrus
@@ -89,6 +89,7 @@ files:
 - lib/musa-dsl/core-ext/attribute-builder.rb
 - lib/musa-dsl/core-ext/deep-copy.rb
 - lib/musa-dsl/core-ext/dynamic-proxy.rb
+- lib/musa-dsl/core-ext/hashify.rb
 - lib/musa-dsl/core-ext/inspect-nice.rb
 - lib/musa-dsl/core-ext/smart-proc-binder.rb
 - lib/musa-dsl/core-ext/with.rb
@@ -163,25 +164,31 @@ files:
 - lib/musa-dsl/repl.rb
 - lib/musa-dsl/repl/repl.rb
 - lib/musa-dsl/sequencer.rb
-- lib/musa-dsl/sequencer/base-sequencer-implementation-control.rb
+- lib/musa-dsl/sequencer/base-sequencer-implementation-every.rb
+- lib/musa-dsl/sequencer/base-sequencer-implementation-move.rb
 - lib/musa-dsl/sequencer/base-sequencer-implementation-play-helper.rb
+- lib/musa-dsl/sequencer/base-sequencer-implementation-play-timed.rb
+- lib/musa-dsl/sequencer/base-sequencer-implementation-play.rb
 - lib/musa-dsl/sequencer/base-sequencer-implementation.rb
-- lib/musa-dsl/sequencer/base-sequencer-public.rb
 - lib/musa-dsl/sequencer/base-sequencer-tick-based.rb
 - lib/musa-dsl/sequencer/base-sequencer-tickless-based.rb
+- lib/musa-dsl/sequencer/base-sequencer.rb
 - lib/musa-dsl/sequencer/sequencer-dsl.rb
 - lib/musa-dsl/sequencer/sequencer.rb
 - lib/musa-dsl/sequencer/timeslots.rb
 - lib/musa-dsl/series.rb
 - lib/musa-dsl/series/array-to-serie.rb
 - lib/musa-dsl/series/base-series.rb
-- lib/musa-dsl/series/hash-serie-splitter.rb
+- lib/musa-dsl/series/flattener-timed-serie.rb
+- lib/musa-dsl/series/hash-or-array-serie-splitter.rb
 - lib/musa-dsl/series/holder-serie.rb
 - lib/musa-dsl/series/main-serie-constructors.rb
 - lib/musa-dsl/series/main-serie-operations.rb
 - lib/musa-dsl/series/proxy-serie.rb
+- lib/musa-dsl/series/quantizer-serie.rb
 - lib/musa-dsl/series/queue-serie.rb
 - lib/musa-dsl/series/series.rb
+- lib/musa-dsl/series/union-timed-series.rb
 - lib/musa-dsl/transcription.rb
 - lib/musa-dsl/transcription/from-gdv-to-midi.rb
 - lib/musa-dsl/transcription/from-gdv-to-musicxml.rb

data/lib/musa-dsl/sequencer/base-sequencer-implementation-control.rb

@@ -1,216 +0,0 @@
-require 'forwardable'
-
-module Musa
-  module Sequencer
-    class BaseSequencer
-      class EventHandler
-        include Musa::Extension::SmartProcBinder
-
-        attr_accessor :continue_parameters
-
-        @@counter = 0
-
-        def initialize(parent = nil)
-          @id = (@@counter += 1)
-
-          @parent = parent
-          @handlers = {}
-
-          @stop = false
-        end
-
-        def stop
-          @stop = true
-        end
-
-        def stopped?
-          @stop
-        end
-
-        def pause
-          raise NotImplementedError
-        end
-
-        def continue
-          @paused = false
-        end
-
-        def paused?
-          @paused
-        end
-
-        def on(event, name: nil, only_once: nil, &block)
-          only_once ||= false
-
-          @handlers[event] ||= {}
-
-          # TODO: add on_rescue: proc { |e| _rescue_block_error(e) } [this method is on Sequencer, not in EventHandler]
-          @handlers[event][name] = {block: SmartProcBinder.new(block), only_once: only_once }
-        end
-
-        def launch(event, *value_parameters, **key_parameters)
-          _launch event, value_parameters, key_parameters
-        end
-
-        def _launch(event, value_parameters = nil, key_parameters = nil)
-          value_parameters ||= []
-          key_parameters ||= {}
-          processed = false
-
-          if @handlers.key? event
-            @handlers[event].each do |name, handler|
-              handler[:block].call *value_parameters, **key_parameters
-              @handlers[event].delete name if handler[:only_once]
-              processed = true
-            end
-          end
-
-          @parent._launch event, value_parameters, key_parameters if @parent && !processed
-        end
-
-        def inspect
-          "EventHandler #{id}"
-        end
-
-        def id
-          if @parent
-            "#{@parent.id}.#{self.class.name.split('::').last}-#{@id}"
-          else
-            "#{self.class.name.split('::').last}-#{@id.to_s}"
-          end
-        end
-
-        alias to_s inspect
-      end
-
-      private_constant :EventHandler
-
-      class PlayControl < EventHandler
-        attr_reader :do_after
-
-        def initialize(parent, after: nil)
-          super parent
-
-          @do_after = []
-
-          self.after &after if after
-        end
-
-        def pause
-          @paused = true
-        end
-
-        def store_continuation(sequencer:, serie:, nl_context:, mode:, decoder:, play_eval:, mode_args:)
-          @continuation_sequencer = sequencer
-          @continuation_parameters = {
-              serie: serie,
-              control: self,
-              nl_context: nl_context,
-              mode: mode,
-              decoder: decoder,
-              play_eval: play_eval,
-              mode_args: mode_args
-          }
-        end
-
-        def continue
-          super
-          @continuation_sequencer.continuation_play(@continuation_parameters) if @continuation_sequencer
-        end
-
-        def after(_bars = nil, &block)
-          # TODO implementar parámetro _bars (?)
-          @do_after << block
-        end
-      end
-
-      private_constant :PlayControl
-
-      class EveryControl < EventHandler
-        attr_reader :duration_value, :till_value, :condition_block, :do_on_stop, :do_after
-
-        attr_accessor :_start_position
-        attr_accessor :_execution_counter
-
-        def initialize(parent, duration: nil, till: nil, condition: nil, on_stop: nil, after_bars: nil, after: nil)
-          super parent
-
-          @duration_value = duration
-          @till_value = till
-          @condition_block = condition
-
-          @do_on_stop = []
-          @do_after = []
-
-          @do_on_stop << on_stop if on_stop
-
-          self.after after_bars, &after if after
-        end
-
-        def duration(value)
-          @duration_value = value.rationalize
-        end
-
-        def till(value)
-          @till_value = value.rationalize
-        end
-
-        def condition(&block)
-          @condition_block = block
-        end
-
-        def on_stop(&block)
-          @do_on_stop << block
-        end
-
-        def after(bars = nil, &block)
-          bars ||= 0
-          @do_after << { bars: bars.rationalize, block: block }
-        end
-      end
-
-      private_constant :EveryControl
-
-      class MoveControl < EventHandler
-        attr_reader :every_control, :do_on_stop, :do_after
-
-        def initialize(parent, duration: nil, till: nil, on_stop: nil, after_bars: nil, after: nil)
-          super parent
-
-          @every_control = EveryControl.new(self, duration: duration, till: till)
-
-          @do_on_stop = []
-          @do_after = []
-
-          @do_on_stop << on_stop if on_stop
-          self.after after_bars, &after if after
-
-          @every_control.on_stop do
-            @stop = true
-            @do_on_stop.each(&:call)
-          end
-        end
-
-        def on_stop(&block)
-          @do_on_stop << block
-        end
-
-        def after(bars = nil, &block)
-          bars ||= 0
-          @do_after << { bars: bars.rationalize, block: block }
-        end
-
-        def stop
-          @every_control.stop
-        end
-
-        def stopped?
-          @stop
-        end
-      end
-
-      private_constant :MoveControl
-    end
-  end
-end
-

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

@@ -1,196 +0,0 @@
-module Musa
-  # TODO: adapt to series prototyping
-  # TODO: full test cases
-
-  module Series
-    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
-end