musa-dsl 0.22.5 → 0.23.3

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

@@ -1,69 +1,53 @@
-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, source_as: :proxy_source)
 
       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.proxy_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
+          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
 
-      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,316 @@
+require_relative 'base-series'
+
+require_relative '../core-ext/with'
+
+module Musa
+  module Series
+    module Composer
+      class Composer
+        using Musa::Extension::Arrayfy
+
+        def initialize(inputs: [:input], outputs: [:output], auto_commit: nil, &block)
+          auto_commit = true if auto_commit.nil?
+
+          @pipelines = {}
+
+          def @pipelines.[]=(name, pipeline)
+            pipeline_to_add = @commited ? pipeline.commit! : pipeline
+            super(name, pipeline_to_add)
+          end
+
+          @dsl = DSLContext.new(@pipelines)
+          @inputs = {}
+          @outputs = {}
+
+          inputs&.each do |input|
+            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|
+            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)
+          @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
+
+        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)
+            @pipelines = pipelines
+          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
+
+            if to_pipeline.is_output && (on || as)
+              raise ArgumentError, "Output pipeline #{to_pipeline.name} only allows default routing"
+            end
+
+            on ||= (as ? :sources : :source)
+
+            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?
+
+
+            to_pipeline[on, as] = from_pipeline
+          end
+
+          def pipeline(name, elements)
+            first, chain = parse(elements)
+            @pipelines[name] = Pipeline.new(name, first_proc: first, chain_proc: chain, pipelines: @pipelines)
+
+            define_singleton_method(name) { name }
+          end
+
+          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 first.nil?
+                  first = new_chain unless first
+                else
+                  chain = chain ? chain >> new_chain : new_chain
+                end
+              end
+
+              [first, chain]
+
+            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
+                  operation_as_chained_proc(operation, parse(parameter))
+                end
+              else
+                raise ArgumentError, "Syntax error: don't know how to handle #{element}"
+              end
+
+            when Symbol
+              operation_as_chained_proc(operation)
+
+            when Proc
+              thing
+
+            else
+              thing
+            end
+          end
+
+          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
+
+            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 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
+              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
+
+          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 :Pipeline
+        private_constant :Route
+        private_constant :DSLContext
+      end
+    end
+  end
+end