musa-dsl 0.22.2 → 0.23.0

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

@@ -0,0 +1,237 @@
+module Musa
+  module Series::Operations
+    def buffered(sync: false)
+      if sync
+        SyncBufferSerie.new(self)
+      else
+        BufferSerie.new(self)
+      end
+    end
+
+    class SyncBufferSerie
+      include Series::Serie.with(source: true)
+
+      def initialize(serie)
+        self.source = serie
+        @history = []
+        @buffers = Set[]
+
+        init
+      end
+
+      private def _restart
+        @source.restart
+        clear_old_history
+      end
+
+      private def _next_value
+        @source.next_value.tap { |value| @history << value unless value.nil? && !@history.empty? && @history.last.nil? }
+      end
+
+      def buffer
+        @buffer ||= Buffer.new(@history)
+        @buffer.send(@get).tap { |_| @buffers << _ }
+      end
+
+      private def clear_old_history
+        min_last_nil_index = @buffers.collect(&:last_nil_index).min
+
+        if min_last_nil_index && min_last_nil_index >=0
+          @history = @history.drop(min_last_nil_index)
+
+          @buffers.each do |b|
+            b._reindex(@history, min_last_nil_index)
+          end
+        end
+      end
+
+      class Buffer
+        include Series::Serie.base
+
+        def initialize(history)
+          @history = history
+          @last_nil_index = -1
+          init
+        end
+
+        attr_reader :last_nil_index
+
+        def _reindex(history, offset)
+          @history = history
+
+          @last_nil_index -= offset
+          @index -= offset
+        end
+
+        private def _init
+          @index = @last_nil_index
+          @wait_restart = false
+        end
+
+        private def _next_value
+          @index += 1 if @index + 1 < @history.size && !@wait_restart
+
+          if @history[@index].nil? && @index < @history.size
+
+            @wait_restart = true
+
+            if @index + 1 < @history.size
+              @last_nil_index = @index
+            end
+          end
+
+          @history[@index]
+        end
+      end
+
+      private_constant :Buffer
+    end
+
+    private_constant :SyncBufferSerie
+
+    class BufferSerie
+      # modo fill_on_restart: cuando una serie hace restart, las demás no se ven afectadas porque siguen recibiendo
+      # todos los elementos de la serie original
+
+      include Series::Serie.with(source: true)
+
+      def initialize(serie)
+        self.source = serie
+
+        @history = [nil]
+        @nils = [0]
+        @buffers = Set[]
+
+        @singleton = nil
+        @buffer = nil
+
+        init
+      end
+
+      def instance
+        @singleton ||= super
+      end
+
+      def buffer
+        @buffer ||= Buffer.new(self)
+        @buffer
+      end
+
+      private def _restart(main)
+        raise ArgumentError, "Can't restart a BufferSerie directly. Should use a buffer instance instead." unless main
+        return if @source_just_restarted
+
+        next_nil = @nils.find { |_| _ > main.index }
+
+        if next_nil && main.index < next_nil
+          main.last_nil_index = main.index = next_nil
+
+        else
+          until _next_value.nil?; end
+          main.last_nil_index = main.index = @nils.last
+        end
+
+        clear_old_history
+
+        @source.restart
+        @source_just_restarted = true
+      end
+
+      private def _next_value
+        @source_just_restarted = false
+        value = @source.next_value
+
+        if value.nil?
+          unless @history.last.nil?
+            @history << nil
+            @nils << @history.size - 1
+          end
+        else
+          @history << value
+        end
+
+        value
+      end
+
+      def _register(buffer)
+        @buffers << buffer
+
+        buffer.history = @history
+        buffer.last_nil_index = 0
+      end
+
+      private def clear_old_history
+        min_last_nil_index = @buffers.collect(&:last_nil_index).min
+
+        if min_last_nil_index && min_last_nil_index >=0
+
+          pre_nils = @nils.clone
+          @history = @history.drop(min_last_nil_index)
+
+          @nils.collect! { |_| _ - min_last_nil_index }
+          @nils.delete_if(&:negative?)
+
+          @buffers.each do |b|
+            b._reindex(@history, min_last_nil_index)
+          end
+        end
+      end
+
+      class Buffer
+        include Series::Serie.with(source: true, private_source: true)
+
+        def initialize(base)
+          self.source = base
+
+          mark_as_prototype! # necesario para que se creen instancias diferentes cada vez que se ejecute BufferSerie.buffer()
+
+          init
+        end
+
+        attr_accessor :history
+        attr_accessor :last_nil_index
+        attr_accessor :index
+
+        def _reindex(history, offset)
+          @history = history
+          @last_nil_index -= offset
+          @index -= offset
+        end
+
+        private def _init
+          @source._register(self) if instance?
+          @index = @last_nil_index
+        end
+
+        private def _restart
+          @source.restart(self)
+          @needs_restart = false
+        end
+
+        private def _next_value
+          value = nil
+
+          unless @needs_restart
+            if @index + 1 < @history.size
+              @index += 1
+              value = @history[@index]
+            else
+              @source.next_value
+              value = _next_value
+            end
+
+            if value.nil?
+              @needs_restart = true
+            end
+          end
+
+          value
+        end
+      end
+
+      private_constant :Buffer
+    end
+
+    private_constant :BufferSerie
+  end
+end

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

@@ -1,95 +1,174 @@
 module Musa
-  module Series
-    module SerieOperations
-      def split
-        Splitter.new(Splitter::BufferedProxy.new(self))
+  module Series::Operations
+    def split
+      Splitter.new(Splitter::BufferedProxy.new(self))
+    end
+
+    class Splitter
+      include Enumerable
+
+      def initialize(proxy)
+        @proxy = proxy
+        @series = {}
       end
 
-      class Splitter
-        def initialize(proxy)
-          @proxy = proxy
-          @series = {}
+      def [](key_or_index)
+        if @series.has_key?(key_or_index)
+          @series[key_or_index]
+        else
+          @series[key_or_index] = Split.new(@proxy, key_or_index)
         end
+      end
 
-        def [](key_or_index)
-          if @series.has_key?(key_or_index)
-            @series[key_or_index]
+      def each
+        if block_given?
+          if @proxy.hash_mode?
+            @proxy.components.each do |key|
+              yield [key, self[key]]
+            end
+          elsif @proxy.array_mode?
+            @proxy.components.each do |index|
+              yield self[index]
+            end
           else
-            @series[key_or_index] = Split.new(@proxy, key_or_index)
+            # do nothing
+          end
+        else
+          if @proxy.hash_mode?
+            @proxy.components.collect { |key| [key, self[key]] }.each
+          elsif @proxy.array_mode?
+            @proxy.components.collect { |index| self[index] }.each
+          else
+            [].each
           end
         end
+      end
 
-        class BufferedProxy
-          include SeriePrototyping
+      def to_hash
+        if @proxy.hash_mode?
+          @proxy.components.collect { |key| [key, self[key]] }.to_h
+        else
+          raise RuntimeError, 'Splitter is not based on Hash: can\'t convert to Hash'
+        end
+      end
 
-          def initialize(hash_or_array_serie)
-            @source = hash_or_array_serie
-            restart restart_source: false
+      def to_ary
+        if @proxy.array_mode?
+          [].tap { |_| @proxy.components.each { |i| _[i] = self[i] } }
+        else
+          raise RuntimeError, 'Splitter is not based on Array: can\'t convert to Array'
+        end
+      end
+
+      class BufferedProxy
+        include Series::Serie::Prototyping
+
+        def initialize(hash_or_array_serie)
+          @source = hash_or_array_serie
+          mark_regarding! @source
+
+          init
+        end
+
+        attr_reader :components
+
+        def hash_mode?; @hash_mode; end
+        def array_mode?; @array_mode; end
+
+        def init
+          infer_components
+        end
 
-            mark_regarding! @source
+        def restart(key_or_index = nil)
+          if key_or_index
+            @asked_to_restart[key_or_index] = true
+          else
+            @components.each { |c| @asked_to_restart[c] = true }
           end
 
-          protected def _instance!
-            super
-            restart
+          if @asked_to_restart.values.all?
+            @source.restart
+            infer_components
           end
+        end
 
-          def restart(restart_source: true)
-            @source.restart if restart_source
+        private def infer_components
+          source = @source.instance
+          sample = source.current_value || source.peek_next_value
+
+          case sample
+          when Array
+            @components = (0..sample.size-1).to_a
+            @values = []
+            @array_mode = true
+            @hash_mode = false
+          when Hash
+            @components = sample.keys.clone
+            @values = {}
+            @array_mode = false
+            @hash_mode = true
+          else
+            @components = []
             @values = nil
+            @array_mode = @hash_mode = false
           end
 
-          def next_value(key_or_index)
-            if @values.nil? || @values[key_or_index].nil? || @values[key_or_index].empty?
-              hash_or_array_value = @source.next_value
-
-              case hash_or_array_value
-              when Hash
-                @values ||= {}
-                hash_or_array_value.each do |k, v|
-                  @values[k] ||= []
-                  @values[k] << v
-                end
-              when Array
-                @values ||= []
-                hash_or_array_value.each_index do |i|
-                  @values[i] ||= []
-                  @values[i] << hash_or_array_value[i]
-                end
-              end
-            end
+          @asked_to_restart = {}
 
-            if @values && !@values[key_or_index].nil?
-              @values[key_or_index].shift
-            else
-              nil
-            end
+          @components.each do |component|
+            @asked_to_restart[component] = false
           end
         end
 
-        class Split
-          include Serie
+        def next_value(key_or_index)
+          if @values[key_or_index].nil? || @values[key_or_index].empty?
 
-          def initialize(proxy, key_or_index)
-            @source = proxy
-            @key_or_index = key_or_index
+            hash_or_array_value = @source.next_value
 
-            mark_regarding! @source
+            case hash_or_array_value
+            when Hash
+              hash_or_array_value.each do |k, v|
+                @values[k] ||= []
+                @values[k] << v
+              end
+            when Array
+              hash_or_array_value.each_index do |i|
+                @values[i] ||= []
+                @values[i] << hash_or_array_value[i]
+              end
+            end
           end
 
-          def _restart
-            @source.restart
+          if @values && !@values[key_or_index].nil?
+            @values[key_or_index].shift
+          else
+            nil
           end
+        end
+      end
 
-          def _next_value
-            @source.next_value(@key_or_index)
-          end
+      class Split
+        include Series::Serie.base
+
+        def initialize(proxy, key_or_index)
+          @source = proxy
+          @key_or_index = key_or_index
+
+          mark_regarding! @source
+        end
+
+        private def _restart
+          @source.restart @key_or_index
         end
 
-        private_constant :Split
+        private def _next_value
+          @source.next_value(@key_or_index)
+        end
       end
 
-      private_constant :Splitter
+      private_constant :Split
     end
+
+    private_constant :Splitter
   end
 end