musa-dsl 0.14.32 → 0.21.5

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

@@ -1,77 +1,80 @@
-require 'musa-dsl/series'
+require_relative '../series'
 
 module Musa
 
   # TODO: adapt to series prototyping
 
-  class Markov
-    include Serie
+  module Markov
+    class Markov
+      include Musa::Extension::SmartProcBinder
+      include Musa::Series::Serie
 
-    attr_accessor :start, :finish, :random, :transitions
+      attr_accessor :start, :finish, :random, :transitions
 
-    def initialize(transitions:, start:, finish: nil, random: nil)
-      @transitions = transitions.clone.freeze
+      def initialize(transitions:, start:, finish: nil, random: nil)
+        @transitions = transitions.clone.freeze
 
-      @start = start
-      @finish = finish
+        @start = start
+        @finish = finish
 
-      @random = Random.new random if random.is_a?(Integer)
-      @random ||= Random.new
+        @random = Random.new random if random.is_a?(Integer)
+        @random ||= Random.new
 
-      @procedure_binders = {}
+        @procedure_binders = {}
 
-      _restart
-    end
-
-    def _restart
-      @current = nil
-      @finished = false
-      @history = []
-    end
+        _restart
+      end
 
-    def _next_value
-      if @finished
+      def _restart
         @current = nil
-      else
-        if @current.nil?
-          @current = @start
-        else
-          if @transitions.has_key? @current
-            options = @transitions[@current]
-
-            case options
-            when Array
-              @current = options[@random.rand(0...options.size)]
-
-            when Hash
-              total = accumulated = 0.0
-              options.each_value { |probability| total += probability.abs }
-              r = @random.rand total
-
-              @current = options.find { |key, probability|
-                accumulated += probability;
-                r >= accumulated - probability && r < accumulated }[0]
+        @finished = false
+        @history = []
+      end
 
-            when Proc
-              procedure_binder = @procedure_binders[options] ||= KeyParametersProcedureBinder.new options
-              @current = procedure_binder.call @history
+      def _next_value
+        if @finished
+          @current = nil
+        else
+          if @current.nil?
+            @current = @start
+          else
+            if @transitions.has_key? @current
+              options = @transitions[@current]
+
+              case options
+              when Array
+                @current = options[@random.rand(0...options.size)]
+
+              when Hash
+                total = accumulated = 0.0
+                options.each_value { |probability| total += probability.abs }
+                r = @random.rand total
+
+                @current = options.find { |key, probability|
+                  accumulated += probability;
+                  r >= accumulated - probability && r < accumulated }[0]
+
+              when Proc
+                procedure_binder = @procedure_binders[options] ||= SmartProcBinder.new(options)
+                @current = procedure_binder.call @history
+              else
+                raise ArgumentError, "Option #{option} is not allowed. Only Array, Hash or Proc are allowed."
+              end
             else
-              raise ArgumentError, "Option #{option} is not allowed. Only Array, Hash or Proc are allowed."
+              raise RuntimeError, "No transition defined for #{@current}"
             end
-          else
-            raise RuntimeError, "No transition defined for #{@current}"
           end
+
+          @history << @current
+          @finished = true if !@finish.nil? && (@current == @finish)
         end
 
-        @history << @current
-        @finished = true if !@finish.nil? && (@current == @finish)
+        @current
       end
 
-      @current
-    end
-
-    def infinite?
-      @finish.nil?
+      def infinite?
+        @finish.nil?
+      end
     end
   end
 end

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

@@ -1,331 +1,343 @@
-require 'musa-dsl/core-ext/key-parameters-procedure-binder'
-require 'musa-dsl/core-ext/arrayfy'
+require_relative '../core-ext/smart-proc-binder'
+require_relative '../core-ext/arrayfy'
+require_relative '../core-ext/with'
+
+using Musa::Extension::Arrayfy
+using Musa::Extension::ExplodeRanges
 
 # TODO: permitir definir un variatio a través de llamadas a métodos y/o atributos, además de a través del block del constructor
 
 module Musa
-  class Variatio
-    def initialize(instance_name, &block)
-      raise ArgumentError, 'instance_name should be a symbol' unless instance_name.is_a?(Symbol)
-      raise ArgumentError, 'block is needed' unless block
+  module Variatio
+    class Variatio
+      include Musa::Extension::SmartProcBinder
 
-      @instance_name = instance_name
+      def initialize(instance_name, &block)
+        raise ArgumentError, 'instance_name should be a symbol' unless instance_name.is_a?(Symbol)
+        raise ArgumentError, 'block is needed' unless block
 
-      main_context = MainContext.new block
+        @instance_name = instance_name
 
-      @constructor = main_context._constructor
-      @fieldset = main_context._fieldset
-      @finalize = main_context._finalize
-    end
+        main_context = MainContext.new &block
+
+        @constructor = main_context._constructor
+        @fieldset = main_context._fieldset
+        @finalize = main_context._finalize
+      end
 
-    def on(**values)
-      constructor_binder = KeyParametersProcedureBinder.new @constructor
-      finalize_binder = KeyParametersProcedureBinder.new @finalize if @finalize
+      def on(**values)
+        constructor_binder = SmartProcBinder.new @constructor
+        finalize_binder = SmartProcBinder.new @finalize if @finalize
 
-      run_fieldset = @fieldset.clone # TODO: verificar que esto no da problemas
+        run_fieldset = @fieldset.clone # TODO: verificar que esto no da problemas
 
-      run_fieldset.components.each do |component|
-        if values.key? component.name
-          component.options = values[component.name].arrayfy.explode_ranges
+        run_fieldset.components.each do |component|
+          if values.key? component.name
+            component.options = values[component.name].arrayfy.explode_ranges
+          end
         end
-      end
 
-      tree_A = generate_eval_tree_A run_fieldset
-      tree_B = generate_eval_tree_B run_fieldset
+        tree_A = generate_eval_tree_A run_fieldset
+        tree_B = generate_eval_tree_B run_fieldset
 
-      parameters_set = tree_A.calc_parameters
+        parameters_set = tree_A.calc_parameters
 
-      combinations = []
+        combinations = []
 
-      parameters_set.each do |parameters_with_depth|
-        instance = @constructor.call constructor_binder.apply(parameters_with_depth)
+        parameters_set.each do |parameters_with_depth|
+          instance = @constructor.call **(constructor_binder._apply(nil, parameters_with_depth).last)
 
-        tree_B.run parameters_with_depth, @instance_name => instance
+          tree_B.run parameters_with_depth, @instance_name => instance
 
-        if @finalize
-          finalize_parameters = finalize_binder.apply parameters_with_depth
-          finalize_parameters[@instance_name] = instance
+          if @finalize
+            finalize_parameters = finalize_binder._apply(nil, parameters_with_depth).last
+            finalize_parameters[@instance_name] = instance
 
-          @finalize.call finalize_parameters
+            @finalize.call **finalize_parameters
+          end
+
+          combinations << instance
         end
 
-        combinations << instance
+        combinations
       end
 
-      combinations
-    end
-
-    def run
-      on
-    end
+      def run
+        on
+      end
 
-    module Helper
-      module_function
+      module Helper
+        module_function
 
-      def list_of_hashes_product(list_of_hashes_1, list_of_hashes_2)
-        result = []
+        def list_of_hashes_product(list_of_hashes_1, list_of_hashes_2)
+          result = []
 
-        list_of_hashes_1.each do |hash1|
-          list_of_hashes_2.each do |hash2|
-            result << hash1.merge(hash2)
+          list_of_hashes_1.each do |hash1|
+            list_of_hashes_2.each do |hash2|
+              result << hash1.merge(hash2)
+            end
           end
-        end
 
-        result
+          result
+        end
       end
-    end
 
-    private_constant :Helper
+      private_constant :Helper
 
-    private
+      private
 
-    def generate_eval_tree_A(fieldset)
-      root = nil
-      current = nil
+      def generate_eval_tree_A(fieldset)
+        root = nil
+        current = nil
 
-      fieldset.components.each do |component|
-        if component.is_a? Field
-          a = A1.new component.name, component.options
-        elsif component.is_a? Fieldset
-          a = A2.new component.name, component.options, generate_eval_tree_A(component)
-        end
+        fieldset.components.each do |component|
+          if component.is_a? Field
+            a = A1.new component.name, component.options
+          elsif component.is_a? Fieldset
+            a = A2.new component.name, component.options, generate_eval_tree_A(component)
+          end
 
-        current.inner = a if current
-        root ||= a
+          current.inner = a if current
+          root ||= a
 
-        current = a
-      end
+          current = a
+        end
 
-      root
-    end
+        root
+      end
 
-    def generate_eval_tree_B(fieldset)
-      affected_field_names = []
-      inner = []
+      def generate_eval_tree_B(fieldset)
+        affected_field_names = []
+        inner = []
 
-      fieldset.components.each do |component|
-        if component.is_a? Fieldset
-          inner << generate_eval_tree_B(component)
-        elsif component.is_a? Field
-          affected_field_names << component.name
+        fieldset.components.each do |component|
+          if component.is_a? Fieldset
+            inner << generate_eval_tree_B(component)
+          elsif component.is_a? Field
+            affected_field_names << component.name
+          end
         end
-      end
 
-      B.new fieldset.name, fieldset.options, affected_field_names, inner, fieldset.with_attributes
-    end
+        B.new fieldset.name, fieldset.options, affected_field_names, inner, fieldset.with_attributes
+      end
 
-    class A
-      attr_reader :parameter_name, :options
-      attr_accessor :inner
+      class A
+        attr_reader :parameter_name, :options
+        attr_accessor :inner
 
-      def initialize(parameter_name, options)
-        @parameter_name = parameter_name
-        @options = options
-        @inner = nil
-      end
+        def initialize(parameter_name, options)
+          @parameter_name = parameter_name
+          @options = options
+          @inner = nil
+        end
 
-      def calc_parameters
-        unless @calc_parameters
-          if inner
-            @calc_parameters = Helper.list_of_hashes_product(calc_own_parameters, @inner.calc_parameters)
-          else
-            @calc_parameters = calc_own_parameters
+        def calc_parameters
+          unless @calc_parameters
+            if inner
+              @calc_parameters = Helper.list_of_hashes_product(calc_own_parameters, @inner.calc_parameters)
+            else
+              @calc_parameters = calc_own_parameters
+            end
           end
-        end
 
-        @calc_parameters
+          @calc_parameters
+        end
       end
-    end
 
-    private_constant :A
+      private_constant :A
 
-    class A1 < A
-      def initialize(parameter_name, options)
-        super parameter_name, options
+      class A1 < A
+        def initialize(parameter_name, options)
+          super parameter_name, options
 
-        @own_parameters = @options.collect { |option| { @parameter_name => option } }
-      end
+          @own_parameters = @options.collect { |option| { @parameter_name => option } }
+        end
 
-      def calc_own_parameters
-        @own_parameters
-      end
+        def calc_own_parameters
+          @own_parameters
+        end
 
-      def inspect
-        "A1 name: #{@parameter_name}, options: #{@options}, inner: #{@inner || 'nil'}"
-      end
+        def inspect
+          "A1 name: #{@parameter_name}, options: #{@options}, inner: #{@inner || 'nil'}"
+        end
 
-      alias to_s inspect
-    end
+        alias to_s inspect
+      end
 
-    private_constant :A1
+      private_constant :A1
 
-    class A2 < A
-      def initialize(parameter_name, options, subcomponent)
-        super parameter_name, options
+      class A2 < A
+        def initialize(parameter_name, options, subcomponent)
+          super parameter_name, options
 
-        @subcomponent = subcomponent
+          @subcomponent = subcomponent
 
-        sub_parameters_set = @subcomponent.calc_parameters
-        result = nil
+          sub_parameters_set = @subcomponent.calc_parameters
+          result = nil
 
-        @options.each do |option|
-          if result.nil?
-            result = sub_parameters_set.collect { |v| { option => v } }
-          else
-            result = Helper.list_of_hashes_product result, sub_parameters_set.collect { |v| { option => v } }
+          @options.each do |option|
+            if result.nil?
+              result = sub_parameters_set.collect { |v| { option => v } }
+            else
+              result = Helper.list_of_hashes_product result, sub_parameters_set.collect { |v| { option => v } }
+            end
           end
-        end
 
-        result = result.collect { |v| { @parameter_name => v } }
+          result = result.collect { |v| { @parameter_name => v } }
 
-        @own_parameters = result
-      end
+          @own_parameters = result
+        end
 
-      def calc_own_parameters
-        @own_parameters
-      end
+        def calc_own_parameters
+          @own_parameters
+        end
 
-      def inspect
-        "A2 name: #{@parameter_name}, options: #{@options}, subcomponent: #{@subcomponent}, inner: #{@inner || 'nil'}"
-      end
+        def inspect
+          "A2 name: #{@parameter_name}, options: #{@options}, subcomponent: #{@subcomponent}, inner: #{@inner || 'nil'}"
+        end
 
-      alias to_s inspect
-    end
+        alias to_s inspect
+      end
 
-    private_constant :A2
+      private_constant :A2
 
-    class B
-      attr_reader :parameter_name, :options, :affected_field_names, :blocks, :inner
+      class B
+        include Musa::Extension::SmartProcBinder
 
-      def initialize(parameter_name, options, affected_field_names, inner, blocks)
-        @parameter_name = parameter_name
-        @options = options
-        @affected_field_names = affected_field_names
-        @inner = inner
+        attr_reader :parameter_name, :options, :affected_field_names, :blocks, :inner
 
-        @procedures = blocks.collect { |proc| KeyParametersProcedureBinder.new proc }
-      end
+        def initialize(parameter_name, options, affected_field_names, inner, blocks)
+          @parameter_name = parameter_name
+          @options = options
+          @affected_field_names = affected_field_names
+          @inner = inner
 
-      def run(parameters_with_depth, parent_parameters = nil)
-        parent_parameters ||= {}
+          @procedures = blocks.collect { |proc| SmartProcBinder.new proc }
+        end
 
-        @options.each do |option|
-          base = @parameter_name == :_maincontext ? parameters_with_depth : parameters_with_depth[@parameter_name][option]
+        def run(parameters_with_depth, parent_parameters = nil)
+          parent_parameters ||= {}
 
-          parameters = base.select { |k, _v| @affected_field_names.include? k }.merge(parent_parameters)
-          parameters[@parameter_name] = option
+          @options.each do |option|
+            base = @parameter_name == :_maincontext ? parameters_with_depth : parameters_with_depth[@parameter_name][option]
 
-          @procedures.each do |procedure_binder|
-            procedure_binder.call parameters
-          end
+            parameters = base.select { |k, _v| @affected_field_names.include? k }.merge(parent_parameters)
+            parameters[@parameter_name] = option
 
-          if @parameter_name == :_maincontext
-            @inner.each do |inner|
-              inner.run parameters_with_depth, parameters
+            @procedures.each do |procedure_binder|
+              procedure_binder.call **parameters
             end
-          else
-            @inner.each do |inner|
-              inner.run parameters_with_depth[@parameter_name][option], parameters
+
+            if @parameter_name == :_maincontext
+              @inner.each do |inner|
+                inner.run parameters_with_depth, parameters
+              end
+            else
+              @inner.each do |inner|
+                inner.run parameters_with_depth[@parameter_name][option], parameters
+              end
             end
           end
         end
-      end
 
-      def inspect
-        "B name: #{@parameter_name}, options: #{@options}, affected_field_names: #{@affected_field_names}, blocks_size: #{@blocks.size}, inner: #{@inner}"
-      end
+        def inspect
+          "B name: #{@parameter_name}, options: #{@options}, affected_field_names: #{@affected_field_names}, blocks_size: #{@blocks.size}, inner: #{@inner}"
+        end
 
-      alias to_s inspect
+        alias to_s inspect
 
-      private
-    end
+        private
+      end
 
-    class FieldsetContext
-      attr_reader :_fieldset
+      class FieldsetContext
+        include Musa::Extension::With
 
-      def initialize(name, options = nil, block)
-        @_fieldset = Fieldset.new name, options.arrayfy.explode_ranges
+        attr_reader :_fieldset
 
-        _as_context_run block
-      end
+        def initialize(name, options = nil, &block)
+          @_fieldset = Fieldset.new name, options.arrayfy.explode_ranges
 
-      def field(name, options = nil)
-        @_fieldset.components << Field.new(name, options.arrayfy.explode_ranges)
-      end
+          with &block
+        end
 
-      def fieldset(name, options = nil, &block)
-        fieldset_context = FieldsetContext.new name, options, block
-        @_fieldset.components << fieldset_context._fieldset
-      end
+        def field(name, options = nil)
+          @_fieldset.components << Field.new(name, options.arrayfy.explode_ranges)
+        end
 
-      def with_attributes(&block)
-        @_fieldset.with_attributes << block
+        def fieldset(name, options = nil, &block)
+          fieldset_context = FieldsetContext.new name, options, &block
+          @_fieldset.components << fieldset_context._fieldset
+        end
+
+        def with_attributes(&block)
+          @_fieldset.with_attributes << block
+        end
       end
-    end
 
-    private_constant :FieldsetContext
+      private_constant :FieldsetContext
 
-    class MainContext < FieldsetContext
-      attr_reader :_constructor, :_finalize
+      class MainContext < FieldsetContext
+        attr_reader :_constructor, :_finalize
 
-      def initialize(block)
-        @_constructor = nil
-        @_finalize = nil
+        def initialize(&block)
+          @_constructor = nil
+          @_finalize = nil
 
-        super :_maincontext, [nil], block
-      end
+          super :_maincontext, [nil], &block
+        end
 
-      def constructor(&block)
-        @_constructor = block
-      end
+        def constructor(&block)
+          @_constructor = block
+        end
 
-      def finalize(&block)
-        @_finalize = block
+        def finalize(&block)
+          @_finalize = block
+        end
       end
-    end
 
-    private_constant :MainContext
+      private_constant :MainContext
 
-    class Field
-      attr_reader :name
-      attr_accessor :options
+      class Field
+        attr_reader :name
+        attr_accessor :options
 
-      def inspect
-        "Field #{@name} options: #{@options}"
-      end
+        def inspect
+          "Field #{@name} options: #{@options}"
+        end
 
-      alias to_s inspect
+        alias to_s inspect
 
-      private
+        private
 
-      def initialize(name, options)
-        @name = name
-        @options = options
+        def initialize(name, options)
+          @name = name
+          @options = options
+        end
       end
-    end
 
-    private_constant :Field
+      private_constant :Field
 
-    class Fieldset
-      attr_reader :name, :with_attributes, :components
-      attr_accessor :options
+      class Fieldset
+        attr_reader :name, :with_attributes, :components
+        attr_accessor :options
 
-      def inspect
-        "Fieldset #{@name} options: #{@options} components: #{@components}"
-      end
+        def inspect
+          "Fieldset #{@name} options: #{@options} components: #{@components}"
+        end
 
-      alias to_s inspect
+        alias to_s inspect
 
-      private
+        private
 
-      def initialize(name, options)
-        @name = name
-        @options = options || [nil]
-        @components = []
-        @with_attributes = []
+        def initialize(name, options)
+          @name = name
+          @options = options || [nil]
+          @components = []
+          @with_attributes = []
+        end
       end
-    end
 
-    private_constant :Fieldset
+      private_constant :Fieldset
+    end
   end
 end