musa-dsl 0.23.1 → 0.23.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38a9835b1d87d869a99fac037037eed22b8eaaf3ad133c70e732578a5631aa79
-  data.tar.gz: 7e9057ff2498fc3039baa1d749cb1c23b5fcc42bdb56879aab38c4fafc3d9468
+  metadata.gz: e7ac7a74db8d0006786f871ba33f6d417704910b11eaab5a568fff617962ad52
+  data.tar.gz: 771ea64584e00fe078f4959537472032ae8438e4cb38b9a7cf1f6798a92a91de
 SHA512:
-  metadata.gz: 191ea705bc3b3378d5660d1e75e63bb53ef0e53d1030fcae2642ff777b9753118b33af4ec7cf0edaec884c793fecded95d41bc6aef9ad41698feb2ca2c04e14e
-  data.tar.gz: 0ee6ed871246af66ed7553a95ec2ca683d874034344b06e3c6128c54f70ec9592b33c7ac0df196dd11dc9a5290bd4c247df008fbf5b4f57af975fbd3a66bb468
+  metadata.gz: 9dd7592546589149d420e6681befca0acea4afde5d07676bb1bfa1f01ec9ff0ce541673618fbd5cd16e549d69034698c682e9a5a8eec61547cbc5be6f8e6c5bf
+  data.tar.gz: 5e4d56c555bc66cf5574a73d58c1c4f17027e4b6256d1b2f866337cefb8f776b8b6ce3987ad586c5171da4e69308a8d957e98b83d1f2387ccff3211e6eaf152a

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

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

@@ -8,34 +8,48 @@ module Musa
       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 +64,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 +143,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)
 
-            elements.each do |e|
-              case e
-              when Hash
-                if e.size == 1
-                  operation = e.keys.first
-                  parameters = e.values.first
+            define_singleton_method(name) { name }
+          end
 
-                  if Musa::Series::Constructors.instance_methods.include?(operation)
-                    raise ArgumentError, "Called constructor '#{operation}' ignoring previous elements" unless last.nil?
+          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
 
-                    last = Musa::Series::Constructors.method(operation).call(*parameters)
+                if first.nil?
+                  first = new_chain unless first
+                else
+                  chain = chain ? chain >> new_chain : new_chain
+                end
+              end
 
-                  elsif Musa::Series::Operations.instance_methods.include?(operation)
-                    first = last = Musa::Series::Constructors.PROXY if last.nil?
-                    last = last.send(operation, *parameters)
+              [first, chain]
 
-                  end
+            when Hash
+              if thing.size == 1
+                operation = thing.first[0] # key
+                parameter = thing.first[1] # value
+
+                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, "Pipeline '#{symbol}' is undefined" if args.empty?
+              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
+              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 +307,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.1'
-  s.date        = '2021-07-02'
+  s.version     = '0.23.3'
+  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.1
+  version: 0.23.3
 platform: ruby
 authors:
 - Javier Sánchez Yeste
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-02 00:00:00.000000000 Z
+date: 2021-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: citrus