musa-dsl 0.14.32 → 0.21.0

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

@@ -1,145 +1,151 @@
-require 'musa-dsl/core-ext/as-context-run'
+require_relative '../core-ext/with'
 
 module Musa
-  class Darwin
-    def initialize(&block)
-      raise ArgumentError, 'block is needed' unless block
+  module Darwin
+    class Darwin
+      def initialize(&block)
+        raise ArgumentError, 'block is needed' unless block
 
-      main_context = MainContext.new block
+        main_context = MainContext.new &block
 
-      @measures = main_context._measures
-      @weights = main_context._weights
-    end
+        @measures = main_context._measures
+        @weights = main_context._weights
+      end
 
-    def select(population)
-      measured_objects = []
+      def select(population)
+        measured_objects = []
 
-      population.each do |object|
-        context = MeasuresEvalContext.new
+        population.each do |object|
+          context = MeasuresEvalContext.new
 
-        context.instance_exec object, &@measures
-        measure = context._measure
+          context.with object, **{}, &@measures
+          measure = context._measure
 
-        measured_objects << { object: object, measure: context._measure } unless measure.died?
-      end
+          measured_objects << { object: object, measure: context._measure } unless measure.died?
+        end
 
-      limits = {}
+        limits = {}
 
-      measured_objects.each do |measured_object|
-        measure = measured_object[:measure]
+        measured_objects.each do |measured_object|
+          measure = measured_object[:measure]
 
-        measure.dimensions.each do |measure_name, value|
-          limit = limits[measure_name] ||= { min: nil, max: nil }
+          measure.dimensions.each do |measure_name, value|
+            limit = limits[measure_name] ||= { min: nil, max: nil }
 
-          limit[:min] = value.to_f if limit[:min].nil? || limit[:min] > value
-          limit[:max] = value.to_f if limit[:max].nil? || limit[:max] < value
+            limit[:min] = value.to_f if limit[:min].nil? || limit[:min] > value
+            limit[:max] = value.to_f if limit[:max].nil? || limit[:max] < value
 
-          limit[:range] = limit[:max] - limit[:min]
+            limit[:range] = limit[:max] - limit[:min]
+          end
         end
-      end
 
-      # warn "Darwin.select: weights #{@weights}"
+        # warn "Darwin.select: weights #{@weights}"
+
+        measured_objects.each do |measured_object|
+          measure = measured_object[:measure]
 
-      measured_objects.each do |measured_object|
-        measure = measured_object[:measure]
+          measure.dimensions.each do |dimension_name, value|
+            limit = limits[dimension_name]
+            measure.normalized_dimensions[dimension_name] = (value - limit[:min]) / limit[:range]
+          end
 
-        measure.dimensions.each do |dimension_name, value|
-          limit = limits[dimension_name]
-          measure.normalized_dimensions[dimension_name] = (value - limit[:min]) / limit[:range]
+          # warn "Darwin.select: #{measured_object[:object]} #{measured_object[:measure]} weight=#{measured_object[:measure].evaluate_weight(@weights).round(2)}"
         end
 
-        # warn "Darwin.select: #{measured_object[:object]} #{measured_object[:measure]} weight=#{measured_object[:measure].evaluate_weight(@weights).round(2)}"
-      end
+        measured_objects.sort! { |a, b| evaluate_weights a[:measure], b[:measure] }
 
-      measured_objects.sort! { |a, b| evaluate_weights a[:measure], b[:measure] }
+        measured_objects.collect { |measured_object| measured_object[:object] }
+      end
 
-      measured_objects.collect { |measured_object| measured_object[:object] }
-    end
+      def evaluate_weights(measure_a, measure_b)
+        measure_b.evaluate_weight(@weights) <=> measure_a.evaluate_weight(@weights)
+      end
 
-    def evaluate_weights(measure_a, measure_b)
-      measure_b.evaluate_weight(@weights) <=> measure_a.evaluate_weight(@weights)
-    end
+      class MainContext
+        include Musa::Extension::With
 
-    class MainContext
-      attr_reader :_measures, :_weights
+        attr_reader :_measures, :_weights
 
-      def initialize(block)
-        @_weights = {}
-        _as_context_run block
-      end
+        def initialize(&block)
+          @_weights = {}
+          with &block
+        end
 
-      def measures(&block)
-        @_measures = block
-      end
+        def measures(&block)
+          @_measures = block
+        end
 
-      def weight(**feature_or_dimension_weights)
-        feature_or_dimension_weights.each do |name, value|
-          @_weights[name] = value
+        def weight(**feature_or_dimension_weights)
+          feature_or_dimension_weights.each do |name, value|
+            @_weights[name] = value
+          end
         end
       end
-    end
 
-    class MeasuresEvalContext
-      def initialize
-        @_features = {}
-        @_dimensions = {}
-        @_died = false
-      end
+      class MeasuresEvalContext
+        include Musa::Extension::With
 
-      def _measure
-        Measure.new @_features, @_dimensions, @_died
-      end
+        def initialize
+          @_features = {}
+          @_dimensions = {}
+          @_died = false
+        end
 
-      def feature(feature_name)
-        @_features[feature_name] = true
-      end
+        def _measure
+          Measure.new @_features, @_dimensions, @_died
+        end
 
-      def dimension(dimension_name, value)
-        @_dimensions[dimension_name] = value
-      end
+        def feature(feature_name)
+          @_features[feature_name] = true
+        end
 
-      def die
-        @_died = true
-      end
+        def dimension(dimension_name, value)
+          @_dimensions[dimension_name] = value
+        end
+
+        def die
+          @_died = true
+        end
 
-      def died?
-        @_died
+        def died?
+          @_died
+        end
       end
-    end
 
-    class Measure
-      attr_reader :features, :dimensions, :normalized_dimensions
+      class Measure
+        attr_reader :features, :dimensions, :normalized_dimensions
 
-      def initialize(features, dimensions, died)
-        @features = features
-        @dimensions = dimensions
-        @died = died
+        def initialize(features, dimensions, died)
+          @features = features
+          @dimensions = dimensions
+          @died = died
 
-        @normalized_dimensions = {}
-      end
+          @normalized_dimensions = {}
+        end
 
-      def died?
-        @died
-      end
+        def died?
+          @died
+        end
 
-      def evaluate_weight(weights)
-        total = 0.0
+        def evaluate_weight(weights)
+          total = 0.0
 
-        unless @died
-          weights.each do |name, weight|
-            total += @normalized_dimensions[name] * weight if @normalized_dimensions.key? name
-            total += weight if @features[name]
+          unless @died
+            weights.each do |name, weight|
+              total += @normalized_dimensions[name] * weight if @normalized_dimensions.key? name
+              total += weight if @features[name]
+            end
           end
+
+          total
         end
 
-        total
-      end
+        def inspect
+          "Measure features=#{@features.collect { |k, _v| k }} dimensions=#{@normalized_dimensions.collect { |k, v| [k, [@dimensions[k].round(5), v.round(2)]] }.to_h}"
+        end
 
-      def inspect
-        "Measure features=#{@features.collect { |k, _v| k }} dimensions=#{@normalized_dimensions.collect { |k, v| [k, [@dimensions[k].round(5), v.round(2)]] }.to_h}"
+        alias to_s inspect
       end
-
-      alias to_s inspect
     end
   end
 end

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

@@ -1,14 +1,19 @@
 module Musa
   module GenerativeGrammar
+    extend self
 
     def N(content = nil, **attributes, &block)
       if block_given? && content.nil?
-        BlockNode.new(attributes, &block)
+        Implementation::BlockNode.new(attributes, &block)
       else
-        FinalNode.new(content, attributes)
+        Implementation::FinalNode.new(content, attributes)
       end
     end
 
+    def PN
+      Implementation::ProxyNode.new
+    end
+
     class OptionElement
       attr_reader :content, :attributes
 
@@ -18,277 +23,267 @@ module Musa
       end
     end
 
-    class Node
-      def or(other)
-        OrNode.new(self, other)
-      end
+    module Implementation
+      class Node
+        def or(other)
+          OrNode.new(self, other)
+        end
 
-      alias_method :|, :or
+        alias_method :|, :or
 
-      def repeat(exactly = nil, min: nil, max: nil)
-        raise ArgumentError, 'Only exactly value or min/max values are allowed' if exactly && (min || max)
+        def repeat(exactly = nil, min: nil, max: nil)
+          raise ArgumentError, 'Only exactly value or min/max values are allowed' if exactly && (min || max)
 
-        min = max = exactly if exactly
+          min = max = exactly if exactly
 
-        if min && min > 0
-          pre = self
+          if min && min > 0
+            pre = self
 
-          (min - 1).times do
-            pre += self
+            (min - 1).times do
+              pre += self
+            end
           end
-        end
 
-        if pre && max == min
-          pre
-        elsif pre && max > min
-          pre + RepeatNode.new(self, max - min)
-        else
-          RepeatNode.new(self, max)
+          if pre && max == min
+            pre
+          elsif pre && max > min
+            pre + RepeatNode.new(self, max - min)
+          else
+            RepeatNode.new(self, max)
+          end
         end
-      end
 
-      def limit(attribute = nil, after_collect_operation = nil, comparison_method = nil, comparison_value = nil, &block)
-        raise ArgumentError, 'Cannot use simplified arguments and yield block at the same time' if (attribute || after_collect_operation || comparison_method || comparison_value) && @block
+        def limit(attribute = nil, after_collect_operation = nil, comparison_method = nil, comparison_value = nil, &block)
+          raise ArgumentError, 'Cannot use simplified arguments and yield block at the same time' if (attribute || after_collect_operation || comparison_method || comparison_value) && @block
 
-        block ||= generate_simple_condition_block(attribute, after_collect_operation, comparison_method, comparison_value)
+          block ||= generate_simple_condition_block(attribute, after_collect_operation, comparison_method, comparison_value)
 
-        ConditionNode.new(self, &block)
-      end
+          ConditionNode.new(self, &block)
+        end
 
-      def next(other)
-        NextNode.new(self, other)
-      end
+        def next(other)
+          NextNode.new(self, other)
+        end
 
-      alias_method :+, :next
+        alias_method :+, :next
 
-      def options(attribute = nil,
-                  after_collect_operation = nil,
-                  comparison_method = nil,
-                  comparison_value = nil,
-                  raw: nil,
-                  content: nil,
-                  &condition)
+        def options(attribute = nil,
+                    after_collect_operation = nil,
+                    comparison_method = nil,
+                    comparison_value = nil,
+                    raw: nil,
+                    content: nil,
+                    &condition)
 
-        raise ArgumentError, 'Cannot use simplified arguments and yield block at the same time' if (attribute || after_collect_operation || comparison_method || comparison_value) && @condition
-        raise ArgumentError, 'Cannot use raw: true and content: option at the same time' if raw && content
+          raise ArgumentError, 'Cannot use simplified arguments and yield block at the same time' if (attribute || after_collect_operation || comparison_method || comparison_value) && @condition
+          raise ArgumentError, 'Cannot use raw: true and content: option at the same time' if raw && content
 
-        raw ||= false
-        content ||= :itself
+          raw ||= false
+          content ||= :itself
 
-        condition ||= generate_simple_condition_block(attribute, after_collect_operation, comparison_method, comparison_value)
+          condition ||= generate_simple_condition_block(attribute, after_collect_operation, comparison_method, comparison_value)
 
-        if raw
-          _options(&condition)
-        else
-          _options(&condition).collect { |o| o.collect(&:content).send(content) }
+          if raw
+            _options(&condition)
+          else
+            _options(&condition).collect { |o| o.collect(&:content).send(content) }
+          end
         end
-      end
 
-      def size
-        options.size
-      end
+        def size
+          options.size
+        end
 
-      alias_method :length, :size
+        alias_method :length, :size
 
-      def [](index)
-        options[index].to_serie.to_node
-      end
+        def [](index)
+          options[index].to_serie.to_node
+        end
 
-      def to_serie(flatten: nil, &condition)
-        flatten ||= true
+        def to_serie(flatten: nil, &condition)
+          flatten ||= true
 
-        serie = _options(&condition).collect { |o| o.collect(&:content) }.to_serie(of_series: true).merge
-        serie = serie.flatten if flatten
+          serie = _options(&condition).collect { |o| o.collect(&:content) }.to_serie(of_series: true).merge
+          serie = serie.flatten if flatten
 
-        serie.prototype
-      end
+          serie.prototype
+        end
 
-      alias_method :s, :to_serie
+        alias_method :s, :to_serie
 
-      def _options(parent: nil, &condition)
-        raise NotImplementedError
-      end
+        def _options(parent: nil, &condition)
+          raise NotImplementedError
+        end
 
-      protected
+        protected
 
-      def generate_simple_condition_block(attribute = nil,
-                                          after_collect_operation = nil,
-                                          comparison_method = nil,
-                                          comparison_value = nil)
+        def generate_simple_condition_block(attribute = nil,
+                                            after_collect_operation = nil,
+                                            comparison_method = nil,
+                                            comparison_value = nil)
 
-        if attribute && after_collect_operation && comparison_method && comparison_value
-          proc do |o|
-            o.collect { |_| _.attributes[attribute] }
-              .send(after_collect_operation)
-              .send(comparison_method, comparison_value)
+          if attribute && after_collect_operation && comparison_method && comparison_value
+            proc do |o|
+              o.collect { |_| _.attributes[attribute] }
+                  .send(after_collect_operation)
+                  .send(comparison_method, comparison_value)
+            end
           end
         end
       end
-    end
 
-    private_constant :Node
+      class ProxyNode < Node
+        attr_accessor :node
 
-    class ProxyNode < Node
-      attr_accessor :node
-
-      def _options(parent: nil, &condition)
-        @node._options parent: parent, &condition
+        def _options(parent: nil, &condition)
+          @node._options parent: parent, &condition
+        end
       end
-    end
 
-    class FinalNode < Node
-      attr_reader :content
-      attr_reader :attributes
+      class FinalNode < Node
+        attr_reader :content
+        attr_reader :attributes
 
-      def initialize(content, attributes)
-        super()
-        @element = OptionElement.new(content, attributes)
-      end
+        def initialize(content, attributes)
+          super()
+          @element = OptionElement.new(content, attributes)
+        end
 
-      def _options(parent: nil, &condition)
-        parent ||= []
+        def _options(parent: nil, &condition)
+          parent ||= []
 
-        if block_given?
-          if yield(parent + [@element])
-            [[@element]]
+          if block_given?
+            if yield(parent + [@element])
+              [[@element]]
+            else
+              []
+            end
           else
-            []
+            [[@element]]
           end
-        else
-          [[@element]]
         end
       end
-    end
-
-    private_constant :FinalNode
 
-    class BlockNode < Node
-      def initialize(attributes, &block)
-        @attributes = attributes
-        @block = block
-      end
+      class BlockNode < Node
+        def initialize(attributes, &block)
+          @attributes = attributes
+          @block = block
+        end
 
-      def _options(parent: nil, &condition)
-        parent ||= []
+        def _options(parent: nil, &condition)
+          parent ||= []
 
-        element = @block.call(parent, @attributes)
-        element = OptionElement.new(element, @attributes) unless element.is_a?(OptionElement)
+          element = @block.call(parent, @attributes)
+          element = OptionElement.new(element, @attributes) unless element.is_a?(OptionElement)
 
-        if block_given?
-          if yield(parent + [element], @attributes)
-            [[element]]
+          if block_given?
+            if yield(parent + [element], @attributes)
+              [[element]]
+            else
+              []
+            end
           else
-            []
+            [[element]]
           end
-        else
-          [[element]]
         end
       end
-    end
 
-    private_constant :BlockNode
+      class ConditionNode < Node
+        def initialize(node, &block)
+          @node = node
+          @block = block
+        end
 
-    class ConditionNode < Node
-      def initialize(node, &block)
-        @node = node
-        @block = block
-      end
+        def _options(parent: nil, &condition)
+          parent ||= []
 
-      def _options(parent: nil, &condition)
-        parent ||= []
+          r = []
 
-        r = []
+          @node._options(parent: parent, &condition).each do |node_option|
+            r << node_option if (!block_given? || yield(parent + node_option)) && @block.call(parent + node_option)
+          end
 
-        @node._options(parent: parent, &condition).each do |node_option|
-          r << node_option if (!block_given? || yield(parent + node_option)) && @block.call(parent + node_option)
+          r
         end
-
-        r
       end
-    end
 
-    private_constant :ConditionNode
+      class OrNode < Node
+        def initialize(node1, node2)
+          @node1 = node1
+          @node2 = node2
+          super()
+        end
 
-    class OrNode < Node
-      def initialize(node1, node2)
-        @node1 = node1
-        @node2 = node2
-        super()
-      end
+        def _options(parent: nil, &condition)
+          parent ||= []
 
-      def _options(parent: nil, &condition)
-        parent ||= []
+          r = []
 
-        r = []
+          @node1._options(parent: parent, &condition).each do |node_option|
+            r << node_option if !block_given? || yield(parent + node_option)
+          end
 
-        @node1._options(parent: parent, &condition).each do |node_option|
-          r << node_option if !block_given? || yield(parent + node_option)
-        end
+          @node2._options(parent: parent, &condition).each do |node_option|
+            r << node_option if !block_given? || yield(parent + node_option)
+          end
 
-        @node2._options(parent: parent, &condition).each do |node_option|
-          r << node_option if !block_given? || yield(parent + node_option)
+          r
         end
-
-        r
       end
-    end
 
-    private_constant :OrNode
-
-    class NextNode < Node
-      def initialize(node, after)
-        @node = node
-        @after = after
-        super()
-      end
+      class NextNode < Node
+        def initialize(node, after)
+          @node = node
+          @after = after
+          super()
+        end
 
-      def _options(parent: nil, &condition)
-        parent ||= []
+        def _options(parent: nil, &condition)
+          parent ||= []
 
-        r = []
-        @node._options(parent: parent, &condition).each do |node_option|
-          @after._options(parent: parent + node_option, &condition).each do |after_option|
-            r << node_option + after_option unless after_option.empty?
+          r = []
+          @node._options(parent: parent, &condition).each do |node_option|
+            @after._options(parent: parent + node_option, &condition).each do |after_option|
+              r << node_option + after_option unless after_option.empty?
+            end
           end
+          r
         end
-        r
       end
-    end
-
-    private_constant :NextNode
 
-    class RepeatNode < Node
-      def initialize(node, max = nil)
-        @node = node
-        @max = max
+      class RepeatNode < Node
+        def initialize(node, max = nil)
+          @node = node
+          @max = max
 
-        super()
-      end
+          super()
+        end
 
-      def _options(parent: nil, depth: nil, &condition)
-        parent ||= []
-        depth ||= 0
+        def _options(parent: nil, depth: nil, &condition)
+          parent ||= []
+          depth ||= 0
 
-        r = []
+          r = []
 
-        if @max.nil? || depth < @max
-          node_options = @node._options(parent: parent, &condition)
+          if @max.nil? || depth < @max
+            node_options = @node._options(parent: parent, &condition)
 
-          node_options.each do |node_option|
-            r << node_option
+            node_options.each do |node_option|
+              r << node_option
 
-            node_suboptions = _options(parent: parent + node_option, depth: depth + 1, &condition)
+              node_suboptions = _options(parent: parent + node_option, depth: depth + 1, &condition)
 
-            node_suboptions.each do |node_suboption|
-              r << node_option + node_suboption
+              node_suboptions.each do |node_suboption|
+                r << node_option + node_suboption
+              end
             end
           end
-        end
 
-        r
+          r
+        end
       end
     end
 
-    private_constant :RepeatNode
+    private_constant :Implementation
   end
 end