musa-dsl 0.23.0 → 0.23.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4a1fb5e2fc74d27266ed15f6edcc335c61b580f3c8fa83fd2c425066230a42b
-  data.tar.gz: 5778babbeeab02ea23d511369946990209929b284e0025f65a67602a1c8fa504
+  metadata.gz: 19683437b5ef89739c0d1283c86b18c547a24dd058ca5013abdea4f9c6335f5c
+  data.tar.gz: 99fea2b0076baf8976050bd9467f4ecafb87a44bad1b37933e741116f1f5ec96
 SHA512:
-  metadata.gz: 33c4b5ab4b14c941ed36ede8919961f0c9bc4d0ec6acf34f2b02f297483c17dfb2e23d270118143c7199f2e073cf001591ad393cae09cbc41e75ac20d8f82c7a
-  data.tar.gz: 4ffcea9a0a82bd7f97ef659ba0a3b03d9b319980df8987986ee0f63eb694d144fc03d0299b3a87665b78a52fafb5d9b840cf10e7461f36cbfe58b30ce4712f22
+  metadata.gz: 26765814873920f392a76fdef1f8f7fc6ce3baca086d47ba443fb74246768943dbe074ebc35b71d946aab7136fd6a433fe03ad897bcff8a16e7045a1fd0c5e7f
+  data.tar.gz: 57a1761af4bb50cb40c75680e89716e8f21b8f5a4ea345b42bdb3e2065f58a315fac8b579227741b601c25f2e2e8a617d7fef2cd799366f7df4b749c9a532ec9

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

@@ -10,7 +10,7 @@ using Musa::Extension::ExplodeRanges
 module Musa
   module MIDIVoices
     class MIDIVoices
-      attr_accessor :log
+      attr_accessor :do_log
 
       def initialize(sequencer:, output:, channels:, do_log: nil)
         do_log ||= false
@@ -24,7 +24,7 @@ module Musa
       end
 
       def reset
-        @voices = @channels.collect { |channel| MIDIVoice.new sequencer: @sequencer, output: @output, channel: channel, log: @do_log }.freeze
+        @voices = @channels.collect { |channel| MIDIVoice.new(sequencer: @sequencer, output: @output, channel: channel, do_log: @do_log) }.freeze
       end
 
       attr_reader :voices
@@ -48,14 +48,14 @@ module Musa
       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, do_log: nil)
+        do_log ||= false
 
         @sequencer = sequencer
         @output = output
         @channel = channel
         @name = name
-        @do_log = log
+        @do_log = do_log
 
         @tick_duration = Rational(1, @sequencer.ticks_per_bar)
 
@@ -64,7 +64,7 @@ module Musa
         @active_pitches = []
         fill_active_pitches @active_pitches
 
-        log 'Warning: voice without output' unless @output
+        @sequencer.logger.warn 'voice without output' unless @output
 
         self
       end
@@ -118,7 +118,7 @@ module Musa
       end
 
       def log(msg)
-        @sequencer.log "voice #{name || @channel}: #{msg}" if @do_log
+        @sequencer.logger.info('MIDIVoice') { "voice #{name || @channel}: #{msg}" } if @do_log
       end
 
       def to_s

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

@@ -38,12 +38,12 @@ module Musa
           include SerieImplementation
 
           if source
-            define_method source_as do ||
+            define_method source_as do
               @source
             end
 
             define_method source_setter do |serie|
-              raise ArgumentError, "New source should be a #{@get}" unless @source.nil? || @source.prototype? == serie&.prototype?
+              raise ArgumentError, "New #{source_as} should be a #{@get}" unless @source.nil? || @source.prototype? == serie&.prototype?
 
               serie ||= Musa::Series::Constructors.NIL
               @get = serie&.instance? ? :instance : :prototype
@@ -294,7 +294,7 @@ module Musa
           @source&.infinite? || false
         end
 
-        def to_a(recursive: nil, duplicate: nil, restart: nil, dr: nil)
+        def to_a(duplicate: nil, recursive: nil, restart: nil, dr: nil)
           recursive ||= false
 
           dr = instance? if dr.nil?

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

@@ -117,18 +117,18 @@ module Musa
         @buffer
       end
 
-      private def _restart(main)
-        raise ArgumentError, "Can't restart a BufferSerie directly. Should use a buffer instance instead." unless main
+      private def _restart(buffer)
+        raise ArgumentError, "Can't restart a BufferSerie directly. Should use a buffer instance instead." unless buffer
         return if @source_just_restarted
 
-        next_nil = @nils.find { |_| _ > main.index }
+        next_nil = @nils.find { |_| _ > buffer.index }
 
-        if next_nil && main.index < next_nil
-          main.last_nil_index = main.index = next_nil
+        if next_nil && buffer.index < next_nil
+          buffer.last_nil_index = buffer.index = next_nil
 
         else
           until _next_value.nil?; end
-          main.last_nil_index = main.index = @nils.last
+          buffer.last_nil_index = buffer.index = @nils.last
         end
 
         clear_old_history
@@ -216,8 +216,7 @@ module Musa
               @index += 1
               value = @history[@index]
             else
-              @source.next_value
-              value = _next_value
+              value = _next_value unless @source.next_value.nil?
             end
 
             if value.nil?

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

@@ -1,19 +1,32 @@
 module Musa
   module Series::Operations
     def split
-      Splitter.new(Splitter::BufferedProxy.new(self))
+      Splitter.new(self)
     end
 
     class Splitter
       include Enumerable
+      include Series::Serie::Prototyping
 
-      def initialize(proxy)
-        @proxy = proxy
+      def initialize(source)
+        @source = source
         @series = {}
       end
 
+      def source=(serie)
+        @source = serie
+        @proxy.source = @source if @proxy
+      end
+
+      protected def _instance!
+        super
+        @proxy = SplitterProxy.new(@source)
+      end
+
       def [](key_or_index)
-        if @series.has_key?(key_or_index)
+        raise "Can't get a component because Splitter is a prototype. To get a component you need a Splitter instance." unless @is_instance
+
+        if @series.key?(key_or_index)
           @series[key_or_index]
         else
           @series[key_or_index] = Split.new(@proxy, key_or_index)
@@ -21,6 +34,8 @@ module Musa
       end
 
       def each
+        raise "Can't iterate because Splitter is a prototype. To iterate you need a Splitter instance." unless @is_instance
+
         if block_given?
           if @proxy.hash_mode?
             @proxy.components.each do |key|
@@ -60,24 +75,24 @@ module Musa
         end
       end
 
-      class BufferedProxy
-        include Series::Serie::Prototyping
-
+      class SplitterProxy
         def initialize(hash_or_array_serie)
           @source = hash_or_array_serie
-          mark_regarding! @source
-
-          init
+          infer_components
         end
 
-        attr_reader :components
+        attr_reader :source
+
+        def source=(hash_or_array_serie)
+          @source = hash_or_array_serie
+          infer_components
+        end
 
         def hash_mode?; @hash_mode; end
+
         def array_mode?; @array_mode; end
 
-        def init
-          infer_components
-        end
+        attr_reader :components
 
         def restart(key_or_index = nil)
           if key_or_index
@@ -151,18 +166,18 @@ module Musa
         include Series::Serie.base
 
         def initialize(proxy, key_or_index)
-          @source = proxy
+          @proxy = proxy
           @key_or_index = key_or_index
 
-          mark_regarding! @source
+          mark_as_instance!
         end
 
         private def _restart
-          @source.restart @key_or_index
+          @proxy.restart(@key_or_index)
         end
 
         private def _next_value
-          @source.next_value(@key_or_index)
+          @proxy.next_value(@key_or_index)
         end
       end
 

data/lib/musa-dsl/series/main-serie-constructors.rb

@@ -566,7 +566,7 @@ module Musa
       end
 
       private def _next_value
-        unless @have_current && @value.nil?
+        unless @sources.empty? || @have_current && @value.nil?
           pre_value = @sources.collect(&:peek_next_value)
 
           nils = 0

data/lib/musa-dsl/series/main-serie-operations.rb

@@ -116,6 +116,10 @@ module Musa
         Anticipate.new self, &block
       end
 
+      def lazy(&block)
+        LazySerieEval.new self, &block
+      end
+
       ###
       ### Implementation
       ###
@@ -1006,6 +1010,45 @@ module Musa
       end
 
       private_constant :HashFromSeriesArray
+
+      class LazySerieEval
+        include Serie.with(source: true, block: true)
+
+        def initialize(serie, &block)
+          self.source = serie
+          self.proc = block
+
+          init
+        end
+
+        def source=(serie)
+          super
+          @processed = nil
+        end
+
+        def proc(&block)
+          super
+          @processed = nil if block
+        end
+
+        def proc=(block)
+          super
+          @processed = nil if block
+        end
+
+        private def _restart
+          @processed = nil
+          @source.restart
+        end
+
+        private def _next_value
+          @processed ||= @block.call(@source)
+          @processed.next_value
+        end
+      end
+
+      private_constant :LazySerieEval
     end
+
   end
 end

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

@@ -7,10 +7,10 @@ module Musa
     end
 
     class ProxySerie
-      include Series::Serie.with(source: true)
+      include Series::Serie.with(source: true, source_as: :proxy_source)
 
       def initialize(serie)
-        self.source = serie
+        self.proxy_source = serie
         init
       end
 
@@ -27,15 +27,19 @@ module Musa
       end
 
       private def method_missing(method_name, *args, **key_args, &block)
-        if @source && @source.respond_to?(method_name)
-          @source.send method_name, *args, **key_args, &block
+        if @source
+          if @source.respond_to?(method_name)
+            @source.send method_name, *args, **key_args, &block
+          else
+            raise NoMethodError, "undefined method '#{method_name}' for proxied #{@source.to_s}"
+          end
         else
           super
         end
       end
 
       private def respond_to_missing?(method_name, include_private)
-        @source && @source.respond_to?(method_name, include_private) # || super
+        @source && @source.respond_to?(method_name, include_private) # || super ??
       end
     end
   end

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

@@ -4,38 +4,58 @@ require_relative '../core-ext/with'
 
 module Musa
   module Series
+    module Operations
+      def composer(&block)
+        Composer::Composer.new(&block).tap { |_| _.input.proxy_source = self}.output
+      end
+    end
+
     module Composer
       class Composer
         using Musa::Extension::Arrayfy
 
-        attr_reader :inputs, :outputs
+        def initialize(inputs: [:input], outputs: [:output], auto_commit: nil, &block)
+          auto_commit = true if auto_commit.nil?
 
-        def initialize(inputs: [:input], outputs: [:output], &block)
           @pipelines = {}
 
-          @links = Set[]
-          @links_from = {}
-          @links_to = {}
+          def @pipelines.[]=(name, pipeline)
+            pipeline_to_add = @commited ? pipeline.commit! : pipeline
+            super(name, pipeline_to_add)
+          end
 
-          @dsl = DSLContext.new(@pipelines, @links, @links_from, @links_to)
+          @dsl = DSLContext.new(@pipelines)
           @inputs = {}
           @outputs = {}
 
           inputs&.each do |input|
-            @inputs[input] = Series::Constructors.PROXY
-            @pipelines[input] = { input: nil, output: @inputs[input].buffered }
+            p = PROXY()
+            @inputs[input] = @pipelines[input] = Pipeline.new(input, input: p, output: p.buffered, pipelines: @pipelines)
 
             @dsl.define_singleton_method(input) { input }
           end
 
           outputs&.each do |output|
-            @outputs[output] = Series::Constructors.PROXY
-            @pipelines[output] = { input: @outputs[output], output: nil }
+            p = PROXY()
+            @outputs[output] = @pipelines[output] = Pipeline.new(output, is_output: true, input: p, output: p, pipelines: @pipelines)
 
             @dsl.define_singleton_method(output) { output }
           end
 
           @dsl.with &block if block
+          commit! if auto_commit
+        end
+
+        def input(name = nil)
+          name ||= :input
+          @inputs[name].input
+        end
+
+        def output(name = nil)
+          raise "Can't access output if the Composer is uncommited. Call '.commit' first." unless @commited
+
+          name ||= :output
+          @outputs[name].output
         end
 
         def route(from, to:, on: nil, as: nil)
@@ -50,15 +70,76 @@ module Musa
           @dsl.with &block
         end
 
+        def commit!
+          raise 'Already commited' if @commited
+
+          @outputs.each_value do |pipeline|
+            pipeline.commit!
+          end
+
+          @commited = true
+        end
+
+        class Pipeline
+          def initialize(name, is_output: false, input: nil, output: nil, first_proc: nil, chain_proc: nil, pipelines:)
+            @name = name
+            @is_output = is_output
+            @input = input
+            @output = output
+            @first_proc = first_proc
+            @chain_proc = chain_proc
+            @routes = {}
+            @pipelines = pipelines
+          end
+
+          attr_reader :name, :is_output
+          attr_accessor :input, :output, :proc
+
+          def [](on, as)
+            @routes[[on, as]]
+          end
+
+          def []=(on, as, source)
+            @routes[[on, as]] = Route.new(on, as, source)
+          end
+
+          def commit!
+            first_serie_operation = @first_proc&.call(NIL())
+            @input ||= first_serie_operation
+
+            @routes.each_value do |route|
+              route.source.commit!
+
+              if @is_output
+                @input.proxy_source = route.source.output.buffer
+              elsif route.as
+                @input.send(route.on)[route.as] = route.source.output.buffer
+              else
+                @input.send("#{route.on.to_s}=".to_sym, route.source.output.buffer)
+              end
+            end
+
+            chain_serie_operation = @chain_proc&.call(@input) || @input
+            @output ||= chain_serie_operation.buffered
+
+            self
+          end
+        end
+
+        class Route
+          def initialize(on, as, source)
+            @on = on
+            @as = as
+            @source = source
+          end
+          attr_accessor :on, :as, :source
+        end
+
         class DSLContext
           include Musa::Extension::With
 
-          def initialize(pipelines, links, links_from, links_to)
+          def initialize(pipelines)
             @pipelines = pipelines
-
-            @links = links
-            @links_from = links_from
-            @links_to = links_to
           end
 
           def route(from, to:, on: nil, as: nil)
@@ -68,69 +149,159 @@ module Musa
             raise ArgumentError, "Pipeline '#{from}' not found." unless from_pipeline
             raise ArgumentError, "Pipeline '#{to}' not found." unless to_pipeline
 
-            @links_from[from] ||= Set[]
+            if to_pipeline.is_output && (on || as)
+              raise ArgumentError, "Output pipeline #{to_pipeline.name} only allows default routing"
+            end
 
-            on ||= as ? :sources : :source
+            on ||= (as ? :sources : :source)
 
-            raise ArgumentError, "Pipeline #{@links_to[[to, on, as]]} already connected to pipeline #{to} on #{on} as #{as}" if @links_to[[to, on, as]]
+            raise ArgumentError,
+                  "Source of pipeline #{to} on #{on} as #{as} already connected to #{to_pipeline[on, as].source.name}" \
+                  unless to_pipeline[on, as].nil?
 
-            if as
-              to_pipeline[:input].send(on)[as] = from_pipeline[:output].buffer
-            else
-              to_pipeline[:input].send("#{on.to_s}=".to_sym, from_pipeline[:output].buffer)
-            end
 
-            @links_from[from] << [to, on, as]
-            @links_to[[to, on, as]] = from
-            @links << [from, to, on, as]
+            to_pipeline[on, as] = from_pipeline
           end
 
           def pipeline(name, elements)
-            first = last = nil
+            first, chain = parse(elements)
+            @pipelines[name] = Pipeline.new(name, first_proc: first, chain_proc: chain, pipelines: @pipelines)
+
+            define_singleton_method(name) { name }
+          end
 
-            elements.each do |e|
-              case e
-              when Hash
-                if e.size == 1
-                  operation = e.keys.first
-                  parameters = e.values.first
+          private def parse(thing)
+            case thing
+            when Array
+              first = chain = nil
+
+              thing.each do |element|
+                case element
+                when Hash
+                  new_chain = parse(element)
+                when Symbol
+                  new_chain = operation_as_chained_proc(element, nil)
+                when Proc
+                  new_chain = operation_as_chained_proc(:map, element)
+                else
+                  raise ArgumentError, "Syntax error: don't know how to handle #{element}"
+                end
 
-                  if Musa::Series::Constructors.instance_methods.include?(operation)
-                    raise ArgumentError, "Called constructor '#{operation}' ignoring previous elements" unless last.nil?
+                if first.nil?
+                  first = new_chain unless first
+                else
+                  chain = chain ? chain >> new_chain : new_chain
+                end
+              end
 
-                    last = Musa::Series::Constructors.method(operation).call(*parameters)
+              [first, chain]
 
-                  elsif Musa::Series::Operations.instance_methods.include?(operation)
-                    first = last = Musa::Series::Constructors.PROXY if last.nil?
-                    last = last.send(operation, *parameters)
+            when Hash
+              if thing.size == 1
+                operation = thing.first[0] # key
+                parameter = thing.first[1] # value
 
-                  end
+                if is_a_series_constructor?(operation)
+                  operation_as_chained_proc(operation, parameter)
                 else
-                  raise ArgumentError, "Don't know how to handle #{e}"
+                  operation_as_chained_proc(operation, parse(parameter))
                 end
-              when Symbol
-                first = last = Musa::Series::Constructors.PROXY if last.nil?
-                # operation == e
-                last = last.send(e) if Musa::Series::Operations.instance_methods.include?(e)
+              else
+                raise ArgumentError, "Syntax error: don't know how to handle #{element}"
               end
 
-              first ||= last
+            when Symbol
+              operation_as_chained_proc(operation)
+
+            when Proc
+              thing
+
+            else
+              thing
             end
+          end
 
-            @pipelines[name] = { input: first, output: last.buffered }
+          private def operation_as_chained_proc(operation, parameter = nil)
+            if is_a_series_constructor?(operation)
+              proc do |last|
+                call_constructor_according_to_last_and_parameter(last, operation, parameter)
+              end
 
-            define_singleton_method(name) { name }
+            elsif is_a_series_operation?(operation)
+              proc { |last| call_operation_according_to_parameter(last, operation, parameter) }
+
+            else
+              # non-series operation
+              proc { |last| call_operation_according_to_parameter(last, operation, parameter) }
+            end
           end
 
-          private def method_missing(symbol, *args, &block)
-            if Musa::Series::Operations.instance_methods.include?(symbol)
-              symbol
-            elsif Musa::Series::Constructors.instance_methods.include?(symbol)
-              symbol
+          private def call_constructor_according_to_last_and_parameter(last, constructor, parameter)
+            case last
+            when Proc
+              call_constructor_according_to_last_and_parameter(last.call, constructor, parameter)
+
+            when Serie
+              # TODO: ignoring last, should make an error?
+              Musa::Series::Constructors.method(constructor).call(*parameter)
+
+            when nil
+              Musa::Series::Constructors.method(constructor).call(*parameter)
+
+            when Array
+              raise "Unexpected parameter #{parameter} for constructor #{constructor} " \
+                "because the previous operation on the pipeline chain returned non-nil #{last}" \
+                unless parameter.nil?
+
+              Musa::Series::Constructors.method(constructor).call(*last)
+
+            when Hash
+              raise "Unexpected parameter #{parameter} for constructor #{constructor} " \
+                "because the previous operation on the pipeline chain returned non-nil #{last}" \
+                unless parameter.nil?
+
+              Musa::Series::Constructors.method(constructor).call(**last)
+
+            else
+              raise ArgumentError, "Don't know how to handle last #{last}"
+            end
+          end
+
+          private def call_operation_according_to_parameter(target, operation, parameter)
+            case parameter
+            when nil
+              target.send(operation)
+            when Symbol
+              target.send(operation).send(parameter)
+            when Proc
+              target.send(operation, &parameter)
+            when Array
+              unless parameter.size == 2 && parameter.all? { |_| _.is_a?(Proc) }
+                raise ArgumentError, "Don't know how to handle parameter #{parameter}"
+              end
+
+              target.send(operation, &(parameter.first >> parameter.last))
             else
-              raise ArgumentError, "Pipeline '#{symbol}' is undefined" if args.empty?
+              target.send(operation, parameter)
+            end
+          end
+
+          private def is_a_series_constructor?(operation)
+            Musa::Series::Constructors.instance_methods.include?(operation)
+          end
 
+          private def is_a_series_operation?(operation)
+            Musa::Series::Operations.instance_methods.include?(operation)
+          end
+
+          private def method_missing(symbol, *args, &block)
+            if is_a_series_constructor?(symbol) || is_a_series_operation?(symbol)
+              symbol
+            elsif args.any? || block
+              args += [block] if block
               pipeline(symbol, args)
+            else # for non-series methods
+              symbol
             end
           end
 
@@ -142,6 +313,8 @@ module Musa
           end
         end
 
+        private_constant :Pipeline
+        private_constant :Route
         private_constant :DSLContext
       end
     end

data/musa-dsl.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name        = 'musa-dsl'
-  s.version     = '0.23.0'
-  s.date        = '2021-06-29'
+  s.version     = '0.23.5'
+  s.date        = '2021-07-28'
   s.summary     = 'A simple Ruby DSL for making complex music'
   s.description = 'Musa-DSL: A Ruby framework and DSL for algorithmic sound and musical thinking and composition'
   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.23.0
+  version: 0.23.5
 platform: ruby
 authors:
 - Javier Sánchez Yeste
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-29 00:00:00.000000000 Z
+date: 2021-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: citrus