musa-dsl 0.14.32 → 0.21.5

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

@@ -1,282 +0,0 @@
-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

data/lib/musa-dsl/neuma.rb

@@ -1 +0,0 @@
-require 'musa-dsl/neuma/neuma'

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

@@ -1,181 +0,0 @@
-module Musa::Neumalang
-  module Neumas # Neumas serie
-    # TODO implementar | ???? neumas | neumas = parallel neumas, no?
-  end
-
-  module Neuma
-    module Parallel
-      include Neuma
-    end
-
-    def |(other)
-      if is_a?(Parallel)
-        clone.tap { |_| _[:parallel] << convert_to_parallel_element(other) }.extend(Parallel)
-      else
-        { kind: :parallel,
-          parallel: [clone, convert_to_parallel_element(other)]
-        }.extend(Parallel)
-      end
-    end
-
-    private
-
-    def convert_to_parallel_element(e)
-      case e
-      when String then { kind: :serie, serie: e.to_neumas }.extend(Neuma)
-      else
-        raise ArgumentError, "Dont know how to convert to neuma #{e}"
-      end
-    end
-  end
-
-  module Dataset
-    class Decorator
-      def process(element, base_duration:, tick_duration:)
-        element
-      end
-
-      def check(value_or_array, &block)
-        if block_given?
-          if value_or_array.is_a?(Array)
-            value_or_array.each { |value| yield value }
-          else
-            yield value_or_array
-          end
-        end
-      end
-    end
-
-    class TwoNeumasDecorator < Decorator
-      def process(element1, element2, base_duration:, tick_duration:)
-        element2
-      end
-    end
-
-    class Decorators
-      attr_reader :decorators
-      attr_accessor :appogiatura_decorator
-
-      def initialize(*decorators, appogiatura_decorator: nil, base_duration: nil, tick_duration: nil)
-        @base_duration = 1/4r
-        @tick_duration = tick_duration || 1/96r
-
-        @appogiatura_decorator = appogiatura_decorator
-        @decorators = decorators
-      end
-
-      def process(element)
-        if @appogiatura_decorator
-          element = @appogiatura_decorator.process(element, base_duration: @base_duration, tick_duration: @tick_duration)
-        end
-
-        @decorators.each do |processor|
-          if element
-            if element.is_a?(Array)
-              element = element.collect { |element_i| processor.process(element_i, base_duration: @base_duration, tick_duration: @tick_duration) }.flatten(1)
-            else
-              element = processor.process(element, base_duration: @base_duration, tick_duration: @tick_duration)
-            end
-          end
-        end
-
-        element
-      end
-    end
-
-    protected
-
-    def positive_sign_of(x)
-      x >= 0 ? '+' : ''
-    end
-
-    def sign_of(x)
-      '++-'[x <=> 0]
-    end
-
-    def velocity_of(x)
-      %w[ppp pp p mp mf f ff fff][x + 3]
-    end
-
-    def modificator_string(modificator, parameter_or_parameters)
-      case parameter_or_parameters
-      when true
-        modificator.to_s
-      when Array
-        "#{modificator.to_s}(#{parameter_or_parameters.collect { |p| parameter_to_string(p) }.join(', ')})"
-      else
-        "#{modificator.to_s}(#{parameter_to_string(parameter_or_parameters)})"
-      end
-    end
-
-    private
-
-    def parameter_to_string(parameter)
-      case parameter
-      when String
-        "\"#{parameter}\""
-      when Numeric
-        "#{parameter}"
-      when Symbol
-        "#{parameter}"
-      end
-    end
-  end
-
-  class ProtoDecoder
-    def subcontext
-      self
-    end
-
-    def decode(_element)
-      raise NotImplementedError
-    end
-  end
-
-  class DifferentialDecoder < ProtoDecoder
-    def decode(attributes)
-      parse attributes
-    end
-
-    def parse(_attributes)
-      raise NotImplementedError
-    end
-  end
-
-  class Decoder < DifferentialDecoder
-    def initialize(base, processor: nil)
-      @base = base
-      @last = base.clone
-
-      @processor = processor
-    end
-
-    attr_accessor :processor
-    attr_reader :base
-
-    def base=(base)
-      @base = base
-      @last = base.clone
-    end
-
-    def subcontext
-      Decoder.new @base
-    end
-
-    def decode(attributes)
-      result = apply parse(attributes), on: @last
-
-      @last = result.clone
-
-      if @processor
-        @processor.process(result)
-      else
-        result
-      end
-    end
-
-    def apply(_action, on:)
-      raise NotImplementedError
-    end
-  end
-end