musa-dsl 0.22.6 → 0.23.0

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

@@ -1,69 +1,49 @@
-module Musa
-  module Series
-    # TODO: adapt to series prototyping
+require_relative 'base-series'
 
+module Musa
+  module Series::Constructors
     def PROXY(serie = nil)
       ProxySerie.new(serie)
     end
 
     class ProxySerie
-      include Serie
-
-      attr_reader :target
+      include Series::Serie.with(source: true)
 
       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'
+        self.source = serie
+        init
       end
 
-      def restart
-        @target.restart if @target
+      private def _restart
+        @source.restart if @source
       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
+      private def _next_value
+        @source.next_value if @source
       end
 
       def infinite?
-        @target.infinite? if @target
+        @source.infinite? if @source
       end
 
-      private
-
-      def method_missing(method_name, *args, **key_args, &block)
-        if @target && @target.respond_to?(method_name)
-          @target.send method_name, *args, **key_args, &block
+      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
         else
           super
         end
       end
 
-      def respond_to_missing?(method_name, include_private)
-        @target && @target.respond_to?(method_name, include_private) # || super
+      private def respond_to_missing?(method_name, include_private)
+        @source && @source.respond_to?(method_name, include_private) # || super
       end
     end
+  end
 
-    module SerieOperations
-      # TODO add test case
-      def proxied
-        Series::ProxySerie.new self
-      end
+  module Series::Operations
+    # TODO add test case
+    def proxy
+      Series::ProxySerie.new(self)
     end
   end
 end

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

@@ -1,34 +1,32 @@
 require_relative '../datasets/e'
 require_relative '../core-ext/inspect-nice'
 
+require_relative 'base-series'
+
 # TODO remove debugging puts, intermediate hash comments on :info and InspectNice
 using Musa::Extension::InspectNice
 
 module Musa
-  module Series
-    module SerieOperations
-      def quantize(reference: nil, step: nil,
-                   value_attribute: nil,
-                   stops: nil,
-                   predictive: nil,
-                   left_open: nil,
-                   right_open: nil)
-
-        Series.QUANTIZE(self,
-                        reference: reference,
-                        step: step,
-                        value_attribute: value_attribute,
-                        stops: stops,
-                        predictive: predictive,
-                        left_open: left_open,
-                        right_open: right_open)
-      end
+  module Series::Operations
+    def quantize(reference: nil, step: nil,
+                 value_attribute: nil,
+                 stops: nil,
+                 predictive: nil,
+                 left_open: nil,
+                 right_open: nil)
+
+      Series.QUANTIZE(self,
+                      reference: reference,
+                      step: step,
+                      value_attribute: value_attribute,
+                      stops: stops,
+                      predictive: predictive,
+                      left_open: left_open,
+                      right_open: right_open)
     end
   end
 
-  module Series
-    extend self
-
+  module Series::Constructors
     def QUANTIZE(time_value_serie,
                  reference: nil, step: nil,
                  value_attribute: nil,
@@ -82,28 +80,27 @@ module Musa
     private_constant :QuantizerTools
 
     class RawQuantizer
-      include Serie
+      include Series::Serie.with(source: true)
       include QuantizerTools
 
       attr_reader :source
 
       def initialize(reference, step, source, value_attribute, stops, left_open, right_open)
+        self.source = source
+
         @reference = reference
         @step_size = step.abs
 
-        @source = source
         @value_attribute = value_attribute
 
         @stops = stops
         @left_open = left_open
         @right_open = right_open
 
-        _restart false
-
-        mark_regarding! source
+        init
       end
 
-      def _restart(restart_sources = true)
+      private def _init
         @last_processed_q_value = nil
         @last_processed_time = nil
 
@@ -111,11 +108,13 @@ module Musa
 
         @points = []
         @segments = []
+      end
 
-        @source.restart if restart_sources
+      private def _restart
+        @source.restart
       end
 
-      def _next_value
+      private def _next_value
         if @stops
           i = 2
 
@@ -348,16 +347,17 @@ module Musa
     private_constant :RawQuantizer
 
     class PredictiveQuantizer
-      include Serie
+      include Series::Serie.with(source: true)
       include QuantizerTools
 
       attr_reader :source
 
       def initialize(reference, step, source, value_attribute, include_stops)
+        self.source = source
+
         @reference = reference
         @step_size = step
 
-        @source = source
         @value_attribute = value_attribute
 
         @include_stops = include_stops
@@ -365,25 +365,25 @@ module Musa
         @halfway_offset = step / 2r
         @crossing_reference = reference - @halfway_offset
 
-        _restart false
-
-        mark_regarding! source
+        init
       end
 
-      def _restart(restart_sources = true)
-        @source.restart if restart_sources
-
+      private def _init
         @last_time = nil
         @crossings = []
 
         @first = true
       end
 
+      private def _restart
+        @source.restart
+      end
+
       def infinite?
         !!@source.infinite?
       end
 
-      def _next_value
+      private def _next_value
         result = nil
 
         first_time, first_value = get_time_value(@source.peek_next_value) if @first

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

@@ -1,51 +1,53 @@
-module Musa
-  module Series
-    # TODO: adapt to series prototyping
+require_relative 'base-series'
 
+module Musa
+  module Series::Constructors
     def QUEUE(*series)
       QueueSerie.new(series)
     end
 
     class QueueSerie
-      include Serie
-
-      attr_reader :targets, :target
+      include Series::Serie.with(sources: true)
 
       def initialize(series)
-        @targets = series.collect(&:instance)
-        @targets ||= []
-
-        mark_as_instance!
-
-        _restart
+        self.sources = series
+        init
       end
 
       def <<(serie)
-        @targets << serie.instance
-        check_current
+        # when queue is a prototype it is also frozen so no serie can be added (it would raise an Exception if tried).
+        # when queue is an instance the added serie should also be an instance (raise an Exception otherwise)
+        #
+        raise ArgumentError, "Only an instance serie can be queued" unless serie.instance?
+
+        @sources << serie
+        @current ||= @sources[@index]
+
         self
       end
 
       def clear
-        @targets.clear
-        restart
+        @sources.clear
+        init
         self
       end
 
-      def _prototype!
-        raise PrototypingSerieError, 'Cannot get prototype of a proxy serie'
+      private def _init
+        @index = 0
+        @current = @sources[@index]
+        @restart_sources = false
       end
 
-      def _restart
-        @index = -1
-        forward
+      private def _restart
+        @current.restart
+        @restart_sources = true
       end
 
-      def _next_value
+      private def _next_value
         value = nil
 
-        if @target
-          value = @target.next_value
+        if @current
+          value = @current.next_value
 
           if value.nil?
             forward
@@ -57,38 +59,32 @@ module Musa
       end
 
       def infinite?
-        !!@targets.find(&:infinite?)
+        !!@sources.find(&:infinite?)
       end
 
-      private
-
-      def forward
+      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
+        @current = @sources[@index]
+        @current&.restart if @restart_sources
       end
 
-      def method_missing(method_name, *args, **key_args, &block)
-        if @target && @target.respond_to?(method_name)
-          @target.send method_name, *args, **key_args, &block
+      private def method_missing(method_name, *args, **key_args, &block)
+        if @current&.respond_to?(method_name)
+          @current.send 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
+      private def respond_to_missing?(method_name, include_private)
+        @current&.respond_to?(method_name, include_private) # || super
       end
     end
+  end
 
-    module SerieOperations
-      def queued
-        Series::QueueSerie.new [self]
-      end
+  module Series::Operations
+    def queued
+      Series::Constructors.QUEUE(self)
     end
   end
 end

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

@@ -0,0 +1,149 @@
+require_relative 'base-series'
+
+require_relative '../core-ext/with'
+
+module Musa
+  module Series
+    module Composer
+      class Composer
+        using Musa::Extension::Arrayfy
+
+        attr_reader :inputs, :outputs
+
+        def initialize(inputs: [:input], outputs: [:output], &block)
+          @pipelines = {}
+
+          @links = Set[]
+          @links_from = {}
+          @links_to = {}
+
+          @dsl = DSLContext.new(@pipelines, @links, @links_from, @links_to)
+          @inputs = {}
+          @outputs = {}
+
+          inputs&.each do |input|
+            @inputs[input] = Series::Constructors.PROXY
+            @pipelines[input] = { input: nil, output: @inputs[input].buffered }
+
+            @dsl.define_singleton_method(input) { input }
+          end
+
+          outputs&.each do |output|
+            @outputs[output] = Series::Constructors.PROXY
+            @pipelines[output] = { input: @outputs[output], output: nil }
+
+            @dsl.define_singleton_method(output) { output }
+          end
+
+          @dsl.with &block if block
+        end
+
+        def route(from, to:, on: nil, as: nil)
+          @dsl.route(from, to: to, on: on, as: as)
+        end
+
+        def pipeline(name, *elements)
+          @dsl.pipeline(name, elements)
+        end
+
+        def update(&block)
+          @dsl.with &block
+        end
+
+        class DSLContext
+          include Musa::Extension::With
+
+          def initialize(pipelines, links, links_from, links_to)
+            @pipelines = pipelines
+
+            @links = links
+            @links_from = links_from
+            @links_to = links_to
+          end
+
+          def route(from, to:, on: nil, as: nil)
+            from_pipeline = @pipelines[from]
+            to_pipeline = @pipelines[to]
+
+            raise ArgumentError, "Pipeline '#{from}' not found." unless from_pipeline
+            raise ArgumentError, "Pipeline '#{to}' not found." unless to_pipeline
+
+            @links_from[from] ||= Set[]
+
+            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]]
+
+            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]
+          end
+
+          def pipeline(name, elements)
+            first = last = nil
+
+            elements.each do |e|
+              case e
+              when Hash
+                if e.size == 1
+                  operation = e.keys.first
+                  parameters = e.values.first
+
+                  if Musa::Series::Constructors.instance_methods.include?(operation)
+                    raise ArgumentError, "Called constructor '#{operation}' ignoring previous elements" unless last.nil?
+
+                    last = Musa::Series::Constructors.method(operation).call(*parameters)
+
+                  elsif Musa::Series::Operations.instance_methods.include?(operation)
+                    first = last = Musa::Series::Constructors.PROXY if last.nil?
+                    last = last.send(operation, *parameters)
+
+                  end
+                else
+                  raise ArgumentError, "Don't know how to handle #{e}"
+                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)
+              end
+
+              first ||= last
+            end
+
+            @pipelines[name] = { input: first, output: last.buffered }
+
+            define_singleton_method(name) { name }
+          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
+            else
+              raise ArgumentError, "Pipeline '#{symbol}' is undefined" if args.empty?
+
+              pipeline(symbol, args)
+            end
+          end
+
+          private def respond_to_missing?(method_name, include_private = false)
+            Musa::Series::Operations.instance_methods.include?(method_name) ||
+            Musa::Series::Constructors.instance_methods.include?(method_name) ||
+            @pipelines.key?(method_name) ||
+            super
+          end
+        end
+
+        private_constant :DSLContext
+      end
+    end
+  end
+end