musa-dsl 0.14.16

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

@@ -0,0 +1,294 @@
+module Musa
+  module GenerativeGrammar
+
+    def N(content = nil, **attributes, &block)
+      if block_given? && content.nil?
+        BlockNode.new(attributes, &block)
+      else
+        FinalNode.new(content, attributes)
+      end
+    end
+
+    class OptionElement
+      attr_reader :content, :attributes
+
+      def initialize(content, attributes = nil)
+        @content = content
+        @attributes = attributes || {}
+      end
+    end
+
+    class Node
+      def or(other)
+        OrNode.new(self, other)
+      end
+
+      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)
+
+        min = max = exactly if exactly
+
+        if min && min > 0
+          pre = self
+
+          (min - 1).times do
+            pre += self
+          end
+        end
+
+        if pre && max == min
+          pre
+        elsif pre && max > min
+          pre + RepeatNode.new(self, max - min)
+        else
+          RepeatNode.new(self, max)
+        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
+
+        block ||= generate_simple_condition_block(attribute, after_collect_operation, comparison_method, comparison_value)
+
+        ConditionNode.new(self, &block)
+      end
+
+      def next(other)
+        NextNode.new(self, other)
+      end
+
+      alias_method :+, :next
+
+      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
+
+        raw ||= false
+        content ||= :itself
+
+        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) }
+        end
+      end
+
+      def size
+        options.size
+      end
+
+      alias_method :length, :size
+
+      def [](index)
+        options[index].to_serie.to_node
+      end
+
+      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.prototype
+      end
+
+      alias_method :s, :to_serie
+
+      def _options(parent: nil, &condition)
+        raise NotImplementedError
+      end
+
+      protected
+
+      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)
+          end
+        end
+      end
+    end
+
+    private_constant :Node
+
+    class ProxyNode < Node
+      attr_accessor :node
+
+      def _options(parent: nil, &condition)
+        @node._options parent: parent, &condition
+      end
+    end
+
+    class FinalNode < Node
+      attr_reader :content
+      attr_reader :attributes
+
+      def initialize(content, attributes)
+        super()
+        @element = OptionElement.new(content, attributes)
+      end
+
+      def _options(parent: nil, &condition)
+        parent ||= []
+
+        if block_given?
+          if yield(parent + [@element])
+            [[@element]]
+          else
+            []
+          end
+        else
+          [[@element]]
+        end
+      end
+    end
+
+    private_constant :FinalNode
+
+    class BlockNode < Node
+      def initialize(attributes, &block)
+        @attributes = attributes
+        @block = block
+      end
+
+      def _options(parent: nil, &condition)
+        parent ||= []
+
+        element = @block.call(parent, @attributes)
+        element = OptionElement.new(element, @attributes) unless element.is_a?(OptionElement)
+
+        if block_given?
+          if yield(parent + [element], @attributes)
+            [[element]]
+          else
+            []
+          end
+        else
+          [[element]]
+        end
+      end
+    end
+
+    private_constant :BlockNode
+
+    class ConditionNode < Node
+      def initialize(node, &block)
+        @node = node
+        @block = block
+      end
+
+      def _options(parent: nil, &condition)
+        parent ||= []
+
+        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
+
+        r
+      end
+    end
+
+    private_constant :ConditionNode
+
+    class OrNode < Node
+      def initialize(node1, node2)
+        @node1 = node1
+        @node2 = node2
+        super()
+      end
+
+      def _options(parent: nil, &condition)
+        parent ||= []
+
+        r = []
+
+        @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
+
+        r
+      end
+    end
+
+    private_constant :OrNode
+
+    class NextNode < Node
+      def initialize(node, after)
+        @node = node
+        @after = after
+        super()
+      end
+
+      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?
+          end
+        end
+        r
+      end
+    end
+
+    private_constant :NextNode
+
+    class RepeatNode < Node
+      def initialize(node, max = nil)
+        @node = node
+        @max = max
+
+        super()
+      end
+
+      def _options(parent: nil, depth: nil, &condition)
+        parent ||= []
+        depth ||= 0
+
+        r = []
+
+        if @max.nil? || depth < @max
+          node_options = @node._options(parent: parent, &condition)
+
+          node_options.each do |node_option|
+            r << node_option
+
+            node_suboptions = _options(parent: parent + node_option, depth: depth + 1, &condition)
+
+            node_suboptions.each do |node_suboption|
+              r << node_option + node_suboption
+            end
+          end
+        end
+
+        r
+      end
+    end
+
+    private_constant :RepeatNode
+  end
+end

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

@@ -0,0 +1,78 @@
+require 'musa-dsl/series'
+
+module Musa
+
+  # TODO: adapt to series prototyping
+
+  class Markov
+    include Serie
+
+    attr_accessor :start, :finish, :random, :transitions
+
+    def initialize(transitions:, start:, finish: nil, random: nil)
+      @transitions = transitions.clone.freeze
+
+      @start = start
+      @finish = finish
+
+      @random = Random.new random if random.is_a?(Integer)
+      @random ||= Random.new
+
+      @procedure_binders = {}
+
+      _restart
+    end
+
+    def _restart
+      @current = nil
+      @finished = false
+      @history = []
+    end
+
+    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] ||= KeyParametersProcedureBinder.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 RuntimeError, "No transition defined for #{@current}"
+          end
+        end
+
+        @history << @current
+        @finished = true if !@finish.nil? && (@current == @finish)
+      end
+
+      @current
+    end
+
+    def infinite?
+      @finish.nil?
+    end
+  end
+end
+

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

@@ -0,0 +1,282 @@
+require 'musa-dsl/core-ext/as-context-run'
+require 'musa-dsl/core-ext/key-parameters-procedure-binder'
+
+module Musa
+  class Rules
+    def initialize(&block)
+      @context = RulesEvalContext.new.tap { |_| _._as_context_run block }
+    end
+
+    def generate_possibilities(object, confirmed_node = nil, node = nil, rules = nil)
+      node ||= Node.new
+      rules ||= @context._rules
+
+      history = confirmed_node.history if confirmed_node
+      history ||= []
+
+      rules = rules.clone
+      rule = rules.shift
+
+      if rule
+        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
+
+          rejection = @context._rejections.find { |rejection| rejection.rejects?(new_object, history) }
+          # TODO: include rejection secondary reasons in rejection message
+
+          new_node.reject! rejection if rejection
+
+          node.children << new_node
+        end
+      end
+
+      unless rules.empty?
+        node.children.each do |node|
+          generate_possibilities node.object, confirmed_node, node, rules unless node.rejected || node.ended?
+        end
+      end
+
+      node
+    end
+
+    def apply(object_or_list, node = nil)
+      list = object_or_list.arrayfy.clone
+
+      node ||= Node.new
+
+      seed = list.shift
+
+      if seed
+        result = generate_possibilities seed, node
+
+        fished = result.fish
+
+        node.reject! 'All children are rejected' if fished.empty?
+
+        fished.each do |object|
+          subnode = node.add(object).mark_as_ended!
+          apply list, subnode
+        end
+      end
+
+      node
+    end
+
+    class RulesEvalContext
+      attr_reader :_rules, :_ended_when, :_rejections
+
+      def rule(name, &block)
+        @_rules ||= []
+        @_rules << Rule.new(name, self, block)
+        self
+      end
+
+      def ended_when(&block)
+        @_ended_when = block
+        self
+      end
+
+      def rejection(reason, &block)
+        @_rejections ||= []
+        @_rejections << Rejection.new(reason, self, block)
+        self
+      end
+
+      def _ended?(object)
+        as_context_run @_ended_when, object
+      end
+
+      class Rule
+        attr_reader :name
+
+        def initialize(name, context, block)
+          @name = name
+          @context = context
+          @block = block
+        end
+
+        def generate_possibilities(object, history)
+          # TODO: optimize context using only one instance for all genereate_possibilities calls
+          context = RuleEvalContext.new @context
+          context.as_context_run @block, object, history
+
+          context._possibilities
+        end
+
+        class RuleEvalContext
+          attr_reader :_possibilities
+
+          def initialize(parent_context)
+            @_parent_context = parent_context
+            @_possibilities = []
+          end
+
+          def possibility(object)
+            @_possibilities << object
+            self
+          end
+
+          private
+
+          def method_missing(method_name, *args, **key_args, &block)
+            if @_parent_context.respond_to? method_name
+              @_parent_context.send_nice method_name, *args, **key_args, &block
+            else
+              super
+            end
+          end
+
+          def respond_to_missing?(method_name, include_private)
+            @_parent_context.respond_to?(method_name, include_private) || super
+          end
+        end
+
+        private_constant :RuleEvalContext
+      end
+
+      private_constant :Rule
+
+      class Rejection
+        attr_reader :reason
+
+        def initialize(reason, context = nil, block = nil)
+          @reason = reason
+          @context = context
+          @block = block
+        end
+
+        def rejects?(object, history)
+          # TODO: optimize context using only one instance for all rejects? checks
+          context = RejectionEvalContext.new @context
+          context.as_context_run @block, object, history
+
+          reasons = context._secondary_reasons.collect { |_| ("#{@reason} (#{_})" if _) || @reason }
+
+          reasons.empty? ? nil : reasons
+        end
+
+        class RejectionEvalContext
+          attr_reader :_secondary_reasons
+
+          def initialize(parent_context)
+            @_parent_context = parent_context
+            @_secondary_reasons = []
+          end
+
+          def reject(secondary_reason = nil)
+            @_secondary_reasons << secondary_reason
+            self
+          end
+
+          private
+
+          def method_missing(method_name, *args, **key_args, &block)
+            if @_parent_context.respond_to? method_name
+              @_parent_context.send_nice method_name, *args, **key_args, &block
+            else
+              super
+            end
+          end
+
+          def respond_to_missing?(method_name, include_private)
+            @_parent_context.respond_to?(method_name, include_private) || super
+          end
+        end
+
+        private_constant :RejectionEvalContext
+      end
+
+      private_constant :Rejection
+    end
+
+    private_constant :RulesEvalContext
+
+    class Node
+      attr_reader :parent, :children, :object, :rejected
+
+      def initialize(object = nil, parent = nil)
+        @parent = parent
+        @children = []
+        @object = object
+
+        @ended = false
+        @rejected = nil
+      end
+
+      def add(object)
+        Node.new(object, self).tap { |n| @children << n }
+      end
+
+      def reject!(rejection)
+        @rejected = rejection
+        self
+      end
+
+      def mark_as_ended!
+        @children.each(&:update_rejection_by_children!)
+
+        if !@children.empty? && !@children.find { |n| !n.rejected }
+          reject! Rejection::AllChildrenRejected
+        end
+
+        @ended = true
+
+        self
+      end
+
+      def ended?
+        @ended
+      end
+
+      def history
+        objects = []
+        n = self
+        while n && n.object
+          objects << n.object
+          n = n.parent
+        end
+
+        objects.reverse
+      end
+
+      def fish
+        fished = []
+
+        @children.each do |node|
+          unless node.rejected
+            if node.ended?
+              fished << node.object
+            else
+              fished += node.fish
+            end
+          end
+        end
+
+        fished
+      end
+
+      def combinations(parent_combination = nil)
+        parent_combination ||= []
+
+        combinations = []
+
+        unless rejected
+          if @children.empty?
+            combinations << parent_combination
+          else
+            @children.each do |node|
+              node.combinations(parent_combination + [node.object]).each do |object|
+                combinations << object
+              end
+            end
+          end
+        end
+
+        combinations
+      end
+    end
+
+    private_constant :Node
+  end
+end