musa-dsl 0.22.6 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e85f0a7bc9ddbb82ea9b6b36741a87c1dc04f2feb1c10ea0f5fcb92e4dfc7a37
-  data.tar.gz: 13ad3537ac0a2e03c07c589174a12a8dd9af5013be79f5bd1ee769820cd94347
+  metadata.gz: b4a1fb5e2fc74d27266ed15f6edcc335c61b580f3c8fa83fd2c425066230a42b
+  data.tar.gz: 5778babbeeab02ea23d511369946990209929b284e0025f65a67602a1c8fa504
 SHA512:
-  metadata.gz: 06f58c414bbbd873179850c378f3022e1bc40eba16325b787824e1cb88b27229c7ac19d08032c8b0385c792ae38324c982970dcc94c91e7fd3d924208b640aa4
-  data.tar.gz: 63398fc18d40799119742df1587735f9736abec4a0c1d97e9a9b29202395b6f4223cea7c01075e95d6f0ae4d752dd7297ba88c9df8c2ac7c76dea439732a8435
+  metadata.gz: 33c4b5ab4b14c941ed36ede8919961f0c9bc4d0ec6acf34f2b02f297483c17dfb2e23d270118143c7199f2e073cf001591ad393cae09cbc41e75ac20d8f82c7a
+  data.tar.gz: 4ffcea9a0a82bd7f97ef659ba0a3b03d9b319980df8987986ee0f63eb694d144fc03d0299b3a87665b78a52fafb5d9b840cf10e7461f36cbfe58b30ce4712f22

data/Gemfile

@@ -1,5 +1,7 @@
 source 'https://rubygems.org'
 
+gem 'logger', '~> 1.4', '>= 1.4.3'
+
 group :neuma do
   gem 'citrus', '~> 3.0.0'
 end
@@ -10,8 +12,8 @@ group :transport do
 end
 
 group :test do
-  gem 'rspec', '~> 3.0'
   gem 'descriptive-statistics'
+  gem 'rspec', '~> 3.0'
 end
 
 group :documentation do

data/lib/musa-dsl.rb

@@ -1,5 +1,5 @@
 module Musa
-  VERSION = '0.22.6'
+  VERSION = '0.23.0'
 end
 
 require_relative 'musa-dsl/core-ext'
@@ -27,21 +27,30 @@ require_relative 'musa-dsl/music'
 require_relative 'musa-dsl/generative'
 
 module Musa::All
+  # Core
+  #
   include Musa::Logger
 
   include Musa::Clock
   include Musa::Transport
   include Musa::Sequencer
 
-  include Musa::Scales
-  include Musa::Chords
+  include Musa::Series
   include Musa::Datasets
 
   include Musa::Neumalang
   include Musa::Neumas
-  include Musa::Matrix
 
-  include Musa::Series
+  include Musa::Transcription
+
+  include Musa::REPL
+
+  # Extensions: ojo, el nombre extensions ya se usa para algunos paquetes de core-ext que funcionan con Refinements
+  #
+  include Musa::Scales
+  include Musa::Chords
+
+  include Musa::Matrix
 
   include Musa::Darwin
   include Musa::Markov
@@ -53,8 +62,5 @@ module Musa::All
 
   include Musa::MusicXML
 
-  include Musa::Transcription
   include Musa::Transcriptors
-
-  include Musa::REPL
 end

data/lib/musa-dsl/core-ext/deep-copy.rb

@@ -118,7 +118,18 @@ module Musa
         end
 
         def deep_copy_proc(register, object, method, freeze)
-          register(register, object, object.dup)
+          if (receiver_dup = registered(object.binding.receiver, register))
+            register(register,
+                     object,
+                     proc do |*args, **kargs|
+                       # when the receiver of the proc is also a duplicated object
+                       # the new copy of the proc should be the new object, not the original one.
+                       #
+                       receiver_dup.instance_exec(object, *args, **kargs, &object)
+                     end)
+          else
+            register(register, object, object.dup)
+          end
         end
 
         def deep_copy_instance_variables(register, object, duplication, method, freeze)

data/lib/musa-dsl/core-ext/smart-proc-binder.rb

@@ -2,8 +2,8 @@ module Musa
   module Extension
     module SmartProcBinder
       class SmartProcBinder
-        def initialize(procedure, on_rescue: nil)
-          @procedure = procedure
+        def initialize(block, on_rescue: nil)
+          @block = block
           @on_rescue = on_rescue
 
           @key_parameters = {}
@@ -12,7 +12,7 @@ module Musa
           @value_parameters_count = 0
           @has_value_rest = false
 
-          procedure.parameters.each do |parameter|
+          block.parameters.each do |parameter|
             @key_parameters[parameter[1]] = nil if parameter[0] == :key || parameter[0] == :keyreq
             @has_key_rest = true if parameter[0] == :keyrest
 
@@ -21,8 +21,12 @@ module Musa
           end
         end
 
+        def proc
+          @block
+        end
+
         def parameters
-          @procedure.parameters
+          @block.parameters
         end
 
         def call(*value_parameters, **key_parameters)
@@ -41,26 +45,24 @@ module Musa
           end
         end
 
-        def __call(value_parameters, key_parameters)
+        private def __call(value_parameters, key_parameters)
           effective_value_parameters, effective_key_parameters = apply(*value_parameters, **key_parameters)
 
           if effective_key_parameters.empty?
             if effective_value_parameters.empty?
-              @procedure.call
+              @block.call
             else
-              @procedure.call *effective_value_parameters
+              @block.call *effective_value_parameters
             end
           else
             if effective_value_parameters.empty?
-              @procedure.call **effective_key_parameters
+              @block.call **effective_key_parameters
             else
-              @procedure.call *effective_value_parameters, **effective_key_parameters
+              @block.call *effective_value_parameters, **effective_key_parameters
             end
           end
         end
 
-        private :__call
-
         def key?(key)
           @has_key_rest || @key_parameters.include?(key)
         end

data/lib/musa-dsl/datasets/p.rb

@@ -13,7 +13,7 @@ module Musa::Datasets
 
       # TODO if instead of using clone (needed because of p.shift) we use index counter the P elements would be evaluated on the last moment
 
-      Musa::Series::E(clone, base_duration) do |p, base_duration|
+      Musa::Series::Constructors.E(clone, base_duration) do |p, base_duration|
         (p.size >= 3) ?
           { from: p.shift,
             duration: p.shift * base_duration,
@@ -46,30 +46,34 @@ module Musa::Datasets
     end
 
     class PtoTimedSerie
-      include Musa::Series::Serie
-
-      attr_reader :origin
+      include Musa::Series::Serie.base
 
       def initialize(origin, base_duration, time_start)
         @origin = origin
         @base_duration = base_duration
         @time_start = time_start
 
-        _restart
+        init
 
         mark_as_prototype!
       end
 
-      def _restart
-        @p = @origin.clone
+      attr_accessor :origin
+      attr_accessor :base_duration
+      attr_accessor :time_start
+
+      private def _init
+        @index = 0
         @time = @time_start
       end
 
-      def _next_value
-        if value = @p.shift
+      private def _next_value
+        if value = @origin[@index]
+          @index += 1
           r = { time: @time, value: value }.extend(AbsTimed)
 
-          delta_time = @p.shift
+          delta_time = @origin[@index]
+          @index += 1
           @time += delta_time * @base_duration if delta_time
 
           r

data/lib/musa-dsl/generative/backboner.rb

@@ -3,13 +3,8 @@ require_relative '../core-ext/with'
 
 using Musa::Extension::Arrayfy
 
-# incluir With -> hecho
-# eliminar method_missing
-# crear rama tb debe recibir la serie de la history -> ya lo hace
-# crear rama puede repetirse (hasta terminar según ended_when) -> no
-#
-# hacer que pueda funcionar en tiempo real? le vas suministrando seeds y le vas diciendo qué opción has elegido (p.ej. para hacer un armonizador en tiempo real)
-# esto mismo sería aplicable en otros generadores? variatio/darwin? generative-grammar? markov?
+# TODO hacer que pueda funcionar en tiempo real? le vas suministrando seeds y le vas diciendo qué opción has elegido (p.ej. para hacer un armonizador en tiempo real)
+# TODO esto mismo sería aplicable en otros generadores? variatio/darwin? generative-grammar? markov?
 
 module Musa
   module Backboner
@@ -17,12 +12,12 @@ module Musa
       include Musa::Extension::With
 
       def initialize(&block)
-        @context = RulesEvalContext.new(&block)
+        @dsl = RulesEvalContext.new(&block)
       end
 
       def generate_possibilities(object, confirmed_node = nil, node = nil, grow_rules = nil)
         node ||= Node.new
-        grow_rules ||= @context._grow_rules
+        grow_rules ||= @dsl._grow_rules
 
         history = confirmed_node.history if confirmed_node
         history ||= []
@@ -33,9 +28,9 @@ module Musa
         if grow_rule
           grow_rule.generate_possibilities(object, history).each do |new_object|
             new_node = Node.new new_object, node
-            new_node.mark_as_ended! if @context._ended? new_object
+            new_node.mark_as_ended! if @dsl._ended? new_object
 
-            rejection = @context._cut_rules.find { |cut_rule| cut_rule.rejects?(new_object, history) }
+            rejection = @dsl._cut_rules.find { |cut_rule| cut_rule.rejects?(new_object, history) }
             # TODO: include rejection secondary reasons in rejection message
 
             new_node.reject! rejection if rejection

data/lib/musa-dsl/generative/generative-grammar.rb

@@ -100,9 +100,7 @@ module Musa
           options[index].to_serie.to_node
         end
 
-        def to_serie(flatten: nil, &condition)
-          flatten ||= true
-
+        def to_serie(flatten: true, &condition)
           serie = _options(&condition).collect { |o| o.collect(&:content) }.to_serie(of_series: true).merge
           serie = serie.flatten if flatten
 

data/lib/musa-dsl/generative/markov.rb

@@ -7,9 +7,8 @@ module Musa
   module Markov
     class Markov
       include Musa::Extension::SmartProcBinder
-      include Musa::Series::Serie
+      include Musa::Series::Serie.base
 
-      attr_accessor :start, :finish, :random, :transitions
 
       def initialize(transitions:, start:, finish: nil, random: nil)
         @transitions = transitions.clone.freeze
@@ -22,23 +21,28 @@ module Musa
 
         @procedure_binders = {}
 
-        _restart
+        init
       end
 
-      def _restart
+      attr_accessor :start
+      attr_accessor :finish
+      attr_accessor :random
+      attr_accessor :transitions
+
+      private def _init
         @current = nil
         @finished = false
         @history = []
       end
 
-      def _next_value
+      private def _next_value
         if @finished
           @current = nil
         else
           if @current.nil?
             @current = @start
           else
-            if @transitions.has_key? @current
+            if @transitions.has_key?(@current)
               options = @transitions[@current]
 
               case options

data/lib/musa-dsl/neumalang/neumalang.rb

@@ -15,7 +15,7 @@ module Musa
           include Musa::Neumas
 
           def value
-            _SE(captures(:expression).collect(&:value), extends: Neuma::Serie)
+            S(*captures(:expression).collect(&:value)).extend(Neuma::Serie)
           end
         end
 

data/lib/musa-dsl/neumas/array-to-neumas.rb

@@ -21,7 +21,7 @@ module Musa
         def convert_to_neumas(e)
           case e
           when Musa::Neumas::Neuma::Serie then e
-          when Musa::Neumas::Neuma::Parallel then _SE([e], extends: Musa::Neumas::Neuma::Serie)
+          when Musa::Neumas::Neuma::Parallel then S(e).extend(Musa::Neumas::Neuma::Serie)
           when String then e.to_neumas
           else
             raise ArgumentError, "Don't know how to convert to neumas #{e}"

data/lib/musa-dsl/sequencer/base-sequencer-implementation-play-helper.rb

@@ -262,11 +262,11 @@ module Musa
 
           when Musa::Series::Serie
             { current_operation: :play,
-              current_parameter: element.restart }
+              current_parameter: element.instance.restart }
 
           when Parallel
             { current_operation: :parallel_play,
-              current_parameter: element.tap { |e| e.each(&:restart) } }
+              current_parameter: element.instance.tap { |e| e.each(&:restart) } }
 
           when Array
             { current_operation: :no_eval_play,

data/lib/musa-dsl/sequencer/sequencer-dsl.rb

@@ -17,11 +17,11 @@ module Musa
                      :position=,
                      :event_handler
 
-      def_delegators :@context, :position, :quantize_position, :logger, :debug
-      def_delegators :@context, :with, :now, :at, :wait, :play, :play_timed, :every, :move
-      def_delegators :@context, :everying, :playing, :moving
-      def_delegators :@context, :launch, :on
-      def_delegators :@context, :run
+      def_delegators :@dsl, :position, :quantize_position, :logger, :debug
+      def_delegators :@dsl, :with, :now, :at, :wait, :play, :play_timed, :every, :move
+      def_delegators :@dsl, :everying, :playing, :moving
+      def_delegators :@dsl, :launch, :on
+      def_delegators :@dsl, :run
 
       def initialize(beats_per_bar = nil,
                      ticks_per_beat = nil,
@@ -37,7 +37,7 @@ module Musa
                                          do_error_log: do_error_log,
                                          log_position_format: log_position_format
 
-        @context = DSLContext.new @sequencer
+        @dsl = DSLContext.new @sequencer
 
         with &block if block_given?
       end

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

@@ -5,209 +5,358 @@ using Musa::Extension::DeepCopy
 
 module Musa
   module Series
-    module SerieOperations end
+    module Constructors; extend self; end
+    module Operations; end
 
-    module SeriePrototyping
-      def prototype?
-        @is_instance ? false : true
-      end
+    include Constructors
 
-      def instance?
-        @is_instance ? true : false
+    module Serie
+      def self.base
+        SerieImplementation
       end
 
-      def prototype
-        if @is_instance
-          @instance_of || (@instance_of = self.clone.tap(&:_prototype!).mark_as_prototype!)
-        else
-          self
+      def self.with(source: false,
+                    source_as: nil,
+                    private_source: nil,
+                    sources: false,
+                    sources_as: nil,
+                    private_sources: nil,
+                    smart_block: false,
+                    block: false,
+                    block_as: nil)
+
+        source_as ||= :source
+        source_setter = (source_as.to_s + '=').to_sym
+
+        sources_as ||= :sources
+        sources_setter = (sources_as.to_s + '=').to_sym
+
+        block_as ||= :proc
+        block_setter = (block_as.to_s + '=').to_sym
+
+        Module.new do
+          include SerieImplementation
+
+          if source
+            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?
+
+              serie ||= Musa::Series::Constructors.NIL
+              @get = serie&.instance? ? :instance : :prototype
+              @source = serie
+              mark_regarding! @source
+            end
+
+            if private_source
+              private source_as
+              private source_setter
+            end
+          end
+
+          if sources
+            define_method sources_as do ||
+              @sources
+            end
+
+            define_method sources_setter do |series|
+              case series
+              when Array
+                getter = @get || ((series.first)&.instance? ? :instance : :prototype)
+                @sources = series.collect(&getter)
+              when Hash
+                getter = @get || ((series.values.first)&.instance? ? :instance : :prototype)
+                @sources = series.transform_values(&getter)
+              else
+                raise ArgumentError, "Only allowed Array or Hash"
+              end
+
+              mark_as! getter
+            end
+
+            if private_sources
+              private sources_as
+              private sources_setter
+            end
+          end
+
+          if smart_block
+            define_method block_as do |&block|
+              if block
+                @block = Musa::Extension::SmartProcBinder::SmartProcBinder.new(block)
+              else
+                @block.proc
+              end
+            end
+
+            define_method block_setter do |block|
+              @block = Musa::Extension::SmartProcBinder::SmartProcBinder.new(block)
+            end
+
+          elsif block
+            define_method block_as do |&block|
+              if block
+                @block = block
+              else
+                @block
+              end
+            end
+
+            define_method block_setter do |block|
+              @block = block
+            end
+          end
         end
       end
 
-      alias_method :p, :prototype
+      module Prototyping
+        def prototype?
+          @is_instance ? false : true
+        end
 
-      def instance
-        if @is_instance
-          self
-        else
-          clone(freeze: false).tap(&:_instance!).mark_as_instance!(self).tap(&:restart)
+        def instance?
+          @is_instance ? true : false
         end
-      end
 
-      alias_method :i, :instance
-
-      # By default, if there is a @source attribute that contains the source of the serie, SeriePrototyping will
-      # handle prototyping/instancing automatically.
-      # If there is a @sources attribute with the eventual several sources, SeriePrototyping will handle them by
-      # default.
-      # If needed the subclasses can override this behaviour to accommodate to real subclass specificities.
-      #
-      protected def _prototype!
-        @source = @source.prototype if @source
-
-        if @sources
-          if @sources.is_a?(Array)
-            @sources = @sources.collect(&:prototype).freeze
-          elsif @sources.is_a?(Hash)
-            @sources = @sources.transform_values(&:prototype).freeze
+        def prototype
+          if @is_instance
+            if !@instance_of
+              @instance_of = clone
+              @instance_of._prototype!
+              @instance_of.mark_as_prototype!
+              @instance_of.init if @instance_of.respond_to?(:init)
+            end
+
+            @instance_of
+          else
+            self
           end
         end
-      end
 
-      protected def _instance!
-        @source = @source.instance if @source
+        alias_method :p, :prototype
 
-        if @sources
-          if @sources.is_a?(Array)
-            @sources = @sources.collect(&:instance)
-          elsif @sources.is_a?(Hash)
-            @sources = @sources.transform_values(&:instance)
+        def instance
+          if @is_instance
+            self
+          else
+            new_instance = clone
+
+            new_instance._instance!
+            new_instance.mark_as_instance!(self)
+            new_instance.init if new_instance.respond_to?(:init)
+
+            new_instance
           end
         end
-      end
 
-      protected def mark_regarding!(source)
-        if source.prototype?
-          mark_as_prototype!
-        else
-          mark_as_instance!
+        alias_method :i, :instance
+
+        # By default, if there is a @source attribute that contains the source of the serie, SeriePrototyping will
+        # handle prototyping/instancing automatically.
+        # If there is a @sources attribute with the eventual several sources, SeriePrototyping will handle them by
+        # default.
+        # If needed the subclasses can override this behaviour to accommodate to real subclass specificities.
+        #
+        protected def _prototype!
+          @source = @source.prototype if @source
+
+          if @sources
+            if @sources.is_a?(Array)
+              @sources = @sources.collect(&:prototype)
+            elsif @sources.is_a?(Hash)
+              @sources = @sources.transform_values(&:prototype)
+            end
+          end
         end
-      end
 
-      protected def mark_as_prototype!
-        @is_instance = nil
-        freeze
-      end
+        protected def _instance!
+          @source = @source.instance if @source
 
-      protected def mark_as_instance!(prototype = nil)
-        @instance_of = prototype
-        @is_instance = true
-        self
-      end
+          if @sources
+            if @sources.is_a?(Array)
+              @sources = @sources.collect(&:instance)
+            elsif @sources.is_a?(Hash)
+              @sources = @sources.transform_values(&:instance)
+            end
+          end
+        end
 
-      class PrototypingSerieError < RuntimeError
-        def initialize(message = nil)
-          message ||= 'This serie is a prototype serie: cannot be consumed. To consume the serie use an instance serie via .instance method'
-          super message
+        protected def mark_as!(getter)
+          case getter
+          when :prototype
+            mark_as_prototype!
+          when :instance
+            mark_as_instance!
+          else
+            raise ArgumentError, "Only can be marked as :prototype or :instance"
+          end
         end
-      end
-    end
 
-    module Serie
-      include SeriePrototyping
-      include SerieOperations
+        protected def mark_regarding!(source)
+          if source.prototype?
+            mark_as_prototype!
+          else
+            mark_as_instance!
+          end
+        end
 
-      def restart
-        raise PrototypingSerieError unless @is_instance
+        protected def mark_as_prototype!
+          @get = :prototype
 
-        @_have_peeked_next_value = false
-        @_peeked_next_value = nil
-        @_have_current_value = false
-        @_current_value = nil
+          @is_instance = nil
+          self
+        end
 
-        _restart if respond_to? :_restart
+        protected def mark_as_instance!(prototype = nil)
+          @get = :instance
 
-        self
+          @instance_of = prototype
+          @is_instance = true
+          self
+        end
+
+        class PrototypingError < RuntimeError
+          def initialize(message = nil)
+            message ||= 'This serie is a prototype serie: cannot be consumed. To consume the serie use an instance serie via .instance method'
+            super message
+          end
+        end
       end
 
-      def next_value
-        raise PrototypingSerieError unless @is_instance
+      module SerieImplementation
+        include Serie
+        include Prototyping
+        include Operations
 
-        unless @_have_current_value && @_current_value.nil?
-          if @_have_peeked_next_value
-            @_have_peeked_next_value = false
-            @_current_value = @_peeked_next_value
-          else
-            @_current_value = _next_value
+        def init
+          @_have_peeked_next_value = false
+          @_peeked_next_value = nil
+          @_have_current_value = false
+          @_current_value = nil
+
+          _init
+
+          self
+        end
+
+        private def _init; end
+
+        def restart(...)
+          raise PrototypingError unless @is_instance
+          init
+          _restart(...)
+
+          self
+        end
+
+        private def _restart; end
+
+        def next_value
+          raise PrototypingError unless @is_instance
+
+          unless @_have_current_value && @_current_value.nil?
+            if @_have_peeked_next_value
+              @_have_peeked_next_value = false
+              @_current_value = @_peeked_next_value
+            else
+              @_current_value = _next_value
+            end
           end
+
+          @_current_value
         end
 
-        @_current_value
-      end
+        private def _next_value; end
 
-      alias_method :v, :next_value
+        alias_method :v, :next_value
 
-      def peek_next_value
-        raise PrototypingSerieError unless @is_instance
+        def peek_next_value
+          raise PrototypingError unless @is_instance
 
-        if !@_have_peeked_next_value
-          @_have_peeked_next_value = true
-          @_peeked_next_value = _next_value
+          if !@_have_peeked_next_value
+            @_have_peeked_next_value = true
+            @_peeked_next_value = _next_value
+          end
+
+          @_peeked_next_value
         end
 
-        @_peeked_next_value
-      end
+        def current_value
+          raise PrototypingError unless @is_instance
 
-      def current_value
-        raise PrototypingSerieError unless @is_instance
+          @_current_value
+        end
 
-        @_current_value
-      end
+        def infinite?
+          @source&.infinite? || false
+        end
 
-      def infinite?
-        false
-      end
+        def to_a(recursive: nil, duplicate: nil, restart: nil, dr: nil)
+          recursive ||= false
 
-      def to_a(recursive: nil, duplicate: nil, restart: nil, dr: nil)
-        recursive ||= false
+          dr = instance? if dr.nil?
 
-        dr ||= instance?
+          duplicate = dr if duplicate.nil?
+          restart = dr if restart.nil?
 
-        duplicate = dr if duplicate.nil?
-        restart = dr if restart.nil?
+          raise 'Cannot convert to array an infinite serie' if infinite?
 
-        raise 'Cannot convert to array an infinite serie' if infinite?
+          array = []
 
-        array = []
+          serie = instance
 
-        serie = instance
+          serie = serie.clone(deep: true) if duplicate
+          serie = serie.restart if restart
 
-        serie = serie.clone(deep: true) if duplicate
-        serie = serie.restart if restart
+          while value = serie.next_value
+            array << if recursive
+                       process_for_to_a(value)
+                     else
+                       value
+                     end
+          end
 
-        while value = serie.next_value
-          array << if recursive
-                     process_for_to_a(value)
-                   else
-                     value
-                   end
+          array
         end
 
-        array
-      end
+        alias_method :a, :to_a
 
-      alias_method :a, :to_a
-
-      def to_node(**attributes)
-        Nodificator.to_node(self, **attributes)
-      end
+        def to_node(**attributes)
+          Nodificator.to_node(self, **attributes)
+        end
 
-      alias_method :node, :to_node
+        alias_method :node, :to_node
 
-      class Nodificator
-        extend Musa::GenerativeGrammar
+        class Nodificator
+          extend Musa::GenerativeGrammar
 
-        def self.to_node(serie, **attributes)
-          N(serie, **attributes)
+          def self.to_node(serie, **attributes)
+            N(serie, **attributes)
+          end
         end
-      end
 
-      private_constant :Nodificator
-
-      private def process_for_to_a(value)
-        case value
-        when Serie
-          value.to_a(recursive: true, restart: false, duplicate: false)
-        when Array
-          a = value.clone
-          a.collect! { |v| v.is_a?(Serie) ? v.to_a(recursive: true, restart: false, duplicate: false) : process_for_to_a(v) }
-        when Hash
-          h = value.clone
-          h.transform_values! { |v| v.is_a?(Serie) ? v.to_a(recursive: true, restart: false, duplicate: false) : process_for_to_a(v) }
-        else
-          value
+        private_constant :Nodificator
+
+        private def process_for_to_a(value)
+          case value
+          when Serie
+            value.to_a(recursive: true, restart: false, duplicate: false)
+          when Array
+            a = value.clone
+            a.collect! { |v| v.is_a?(Serie) ? v.to_a(recursive: true, restart: false, duplicate: false) : process_for_to_a(v) }
+          when Hash
+            h = value.clone
+            h.transform_values! { |v| v.is_a?(Serie) ? v.to_a(recursive: true, restart: false, duplicate: false) : process_for_to_a(v) }
+          else
+            value
+          end
         end
       end
+
+      private_constant :SerieImplementation
     end
   end
 end