musa-dsl 0.14.16

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

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

data/lib/musa-dsl/neuma.rb

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

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

@@ -0,0 +1,294 @@
+grammar Neumalang
+
+	rule content
+		sentences
+	end
+
+	rule sentences
+		(spaces (sentence spaces)*) <Musa::Neumalang::Parser::Sentences>
+	end
+
+	rule sentence
+		expression
+	end
+
+	rule expression
+		variable_assign | call_methods_expression | object_expression | event
+	end
+
+	rule object_expression
+		braced_command | reference_expression | bracketed_expression | use_variable | constant | neuma
+	end
+
+	rule reference_expression
+		(ampersand spaces expression) <Musa::Neumalang::Parser::ReferenceExpression>
+	end
+
+	rule variable_assign
+		((use_variable spaces equal spaces)+ expression) <Musa::Neumalang::Parser::VariableAssign>
+	end
+
+	rule event
+		(double_colon name parameters?) <Musa::Neumalang::Parser::Event>
+	end
+
+	rule braced_command
+		(lbrace spaces complex_command spaces rbrace parameters?) <Musa::Neumalang::Parser::BracedCommand>
+	end
+
+	rule call_methods_expression
+		(object_expression (dot method_call)+) <Musa::Neumalang::Parser::CallMethodsExpression>
+	end
+
+	rule bracketed_expression
+		bracketed_bar_sentences | bracketed_sentences
+	end
+
+	rule method_call
+		(name parameters?) { { method: capture(:name).value.to_sym }.merge(capture(:parameters) ? capture(:parameters).value : {}) }
+	end
+
+	rule neuma
+        appogiatura_neuma | simple_neuma
+	end
+
+	rule appogiatura_neuma
+	    (lpar spaces a:simple_neuma spaces rpar spaces b:simple_neuma) { capture(:b).value.tap { |_| _[:neuma] << { appogiatura: capture(:a).value[:neuma] } } }
+	end
+
+	rule simple_neuma
+		neuma_as_dotted_attributes_beginning_with_dot | neuma_as_dotted_attributes_beginning_with_simple_attribute | neuma_between_angles_attributes
+	end
+
+	rule constant
+		number | symbol | string
+	end
+
+	rule bracketed_bar_sentences
+		(lbracket spaces aa:sentences (bar spaces bb:sentences)+ rbracket) <Musa::Neumalang::Parser::BracketedBarSentences>
+	end
+
+	rule bracketed_sentences
+		(lbracket spaces sentences rbracket) <Musa::Neumalang::Parser::BracketedSentences>
+	end
+
+	rule use_variable
+		(at name) <Musa::Neumalang::Parser::UseVariable>
+	end
+
+	rule parameters
+		parameters_a | parameters_b | parameters_c
+	end
+
+	rule parameters_a
+		(lpar positional_parameters comma key_parameters rpar) { { value_parameters: capture(:positional_parameters).value, key_parameters: capture(:key_parameters).value } }
+	end
+
+	rule parameters_b
+		(lpar key_parameters rpar) { { key_parameters: capture(:key_parameters).value } }
+	end
+
+	rule parameters_c
+		(lpar positional_parameters rpar) { { value_parameters: capture(:positional_parameters).value } }
+	end
+
+	rule positional_parameters
+		(spaces a:sentence (spaces comma spaces b:sentence spaces)* spaces) {
+			[ capture(:a).value ] + captures(:b).collect { |c| c.value }
+		}
+	end
+
+	rule key_parameters
+		(spaces a:key_value_parameter (spaces comma spaces b:key_value_parameter spaces)* spaces) {
+
+			result = capture(:a).value.clone
+
+			captures(:b).each { |c| result.merge! c.value }
+
+			result
+		}
+	end
+
+	rule key_value_parameter
+		(key:name colon spaces value:sentence) { { capture(:key).value.to_sym => capture(:value).value } }
+	end
+
+	rule complex_command
+	    (everything_except_braces? lbrace spaces complex_command spaces rbrace)* everything_except_braces?
+	end
+
+
+	rule neuma_as_dotted_attributes_beginning_with_simple_attribute
+	    (a:simple_attribute (dot b:attribute)*) <Musa::Neumalang::Parser::NeumaAsDottedAttributesBeginningWithSimpleAttribute>
+	end
+
+	rule neuma_as_dotted_attributes_beginning_with_dot
+	    ((dot attribute)+ | dot) <Musa::Neumalang::Parser::NeumaAsDottedAttributesBeginningWithDot>
+	end
+
+	rule neuma_between_angles_attributes
+		(langle spaces simple_attribute? spaces (attribute spaces)* rangle) <Musa::Neumalang::Parser::NeumaBetweenAnglesAttributes>
+	end
+
+    rule attribute
+        (modifier_attribute | simple_attribute)
+    end
+
+	rule simple_attribute
+		everything_that_can_be_an_attribute !colon
+	end
+
+	rule modifier_attribute
+	    modifier_call_without_parameters | modifier_call_with_parameters
+	end
+
+	rule modifier_call_without_parameters
+		(name &attribute_change) { { modifier: capture(:name).value.to_sym } }
+	end
+
+	rule modifier_call_with_parameters
+		(name modifier_parameters) { { modifier: capture(:name).value.to_sym }.merge(capture(:modifier_parameters) ? capture(:modifier_parameters).value : {}) }
+	end
+
+    rule modifier_parameters
+        (lpar modifier_positional_parameters rpar) { { parameters: capture(:modifier_positional_parameters).value } }
+    end
+
+	rule modifier_positional_parameters
+		(spaces a:modifier_parameter_constant (spaces comma spaces b:modifier_parameter_constant spaces)* spaces) {
+		    if capture(:b)
+			    [ capture(:a).value ] + captures(:b).collect { |c| c.value }
+            else
+                capture(:a).value
+            end
+        }
+	end
+
+    rule modifier_parameter_constant
+        raw_number | raw_symbol | raw_string
+    end
+
+	rule number
+    	float | rational | integer
+  	end
+
+	rule raw_number
+    	raw_float | raw_rational | raw_integer
+  	end
+
+  	rule symbol
+  		(colon name) <Musa::Neumalang::Parser::Symbol>
+  	end
+
+  	rule raw_symbol
+  		(name &spaces) { capture(:name).value.to_sym }
+  	end
+
+  	rule string
+  		(double_quote everything_except_double_quote double_quote) <Musa::Neumalang::Parser::String>
+  	end
+
+  	rule raw_string
+  		(double_quote everything_except_double_quote double_quote) { capture(:everything_except_double_quote).value }
+  	end
+
+  	rule float
+    	(single_quote str:(digits dot digits) spaces) <Musa::Neumalang::Parser::Float>
+  	end
+
+  	rule raw_float
+    	(str:(digits dot digits) spaces) { capture(:str).value.to_f }
+  	end
+
+  	rule integer
+    	(single_quote digits spaces) <Musa::Neumalang::Parser::Integer>
+  	end
+
+  	rule raw_integer
+    	(digits spaces) { capture(:digits).value.to_i }
+  	end
+
+  	rule rational
+    	(single_quote str:(digits slash digits) spaces) <Musa::Neumalang::Parser::Rational>
+  	end
+
+  	rule raw_rational
+    	(str: (digits slash digits) spaces) { capture(:str).value.to_r }
+  	end
+
+	rule comment
+		(lcomment complex_comment rcomment) | hash_comment
+	end
+
+	rule hash_comment
+	    (hsh_at_start_of_line | space+) everything_until_eol
+	end
+
+	rule complex_comment
+		everything_except_comment? (lcomment complex_comment rcomment)* everything_except_comment?
+	end
+
+  	rule digits
+    	[0-9]+ ('_' [0-9]+)*
+  	end
+
+	rule name
+		/[[:alpha:]]\w*/
+	end
+
+	rule everything_that_can_be_an_attribute
+		/[^({|}|\[|\]|\(|\)|\<|\>|.|,|:|=| |\t|\n|\r|\"|@|&|\|)]+/m
+	end
+
+    rule attribute_change
+        space | dot | rbracket | rpar | rbrace | eol
+    end
+
+	rule everything_until_eol
+		~/$/
+	end
+
+	rule everything_except_comment
+		~/((\*\/)|(\/\*))/m
+	end
+
+	rule everything_except_braces
+		~/({|})/m
+	end
+
+	rule everything_except_double_quote
+		~/(\")/m
+	end
+
+	rule hsh_at_start_of_line
+	    /\A#/
+	end
+
+	rule double_quote '"' end
+	rule single_quote '\'' end
+	rule dot '.' end
+	rule comma ',' end
+	rule colon ':' end
+	rule double_colon '::' end
+	rule bar '|' end
+	rule slash '/' end
+	rule lpar '(' end
+	rule rpar ')' end
+	rule lbrace '{' end
+	rule rbrace '}' end
+	rule lbracket '[' end
+	rule rbracket ']' end
+	rule langle '<' end
+	rule rangle '>' end
+	rule at '@' end
+	rule ampersand '&' end
+	rule equal '=' end
+	rule lcomment '/*' end
+	rule rcomment '*/' end
+	rule hsh '#' end
+	rule eol /$/ end
+
+	rule space /[ \t\n\r]/m end
+	rule spaces (space | comment)* end
+
+end

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

@@ -0,0 +1,179 @@
+require 'musa-dsl/series'
+require 'citrus'
+
+module Musa::Neumalang
+  module Parser
+    module Sentences
+      include Musa::Series
+
+      def value
+        _SE(captures(:sentence).collect(&:value), extends: Neumas)
+      end
+    end
+
+    module BracketedBarSentences
+      include Musa::Series
+
+      def value
+        { kind: :parallel,
+          parallel: [{ kind: :serie, serie: S(*capture(:aa).value) }] + captures(:bb).collect { |c| { kind: :serie, serie: S(*c.value) } }
+        }.extend(Neuma::Parallel)
+      end
+    end
+
+    module BracketedSentences
+      include Musa::Series
+
+      def value
+        { kind: :serie,
+          serie: S(*capture(:sentences).value) }.extend Neuma
+      end
+    end
+
+    module ReferenceExpression
+      def value
+        { kind: :reference,
+          reference: capture(:expression).value }.extend Neuma
+      end
+    end
+
+    module VariableAssign
+      def value
+        { kind: :assign_to,
+          assign_to: captures(:use_variable).collect { |c| c.value[:use_variable] }, assign_value: capture(:expression).value
+        }.extend Neuma
+      end
+    end
+
+    module Event
+      def value
+        { kind: :event,
+          event: capture(:name).value.to_sym
+        }.merge(capture(:parameters) ? capture(:parameters).value : {}).extend Neuma
+      end
+    end
+
+    module BracedCommand
+      def value
+        { kind: :command,
+          command: eval("proc { #{capture(:complex_command).value.strip} }")
+        }.merge(capture(:parameters) ? capture(:parameters).value : {}).extend Neuma
+      end
+    end
+
+    module CallMethodsExpression
+      def value
+        { kind: :call_methods,
+          call_methods: captures(:method_call).collect(&:value),
+          on: capture(:object_expression).value }.extend Neuma
+      end
+    end
+
+    module UseVariable
+      def value
+        { kind: :use_variable,
+          use_variable: "@#{capture(:name).value}".to_sym }.extend Neuma
+      end
+    end
+
+    module NeumaAsDottedAttributesBeginningWithSimpleAttribute
+      def value
+        { kind: :neuma,
+          neuma: (capture(:a) ? [capture(:a).value] : []) + captures(:b).collect(&:value) }.extend Neuma
+      end
+    end
+
+    module NeumaAsDottedAttributesBeginningWithDot
+      def value
+        { kind: :neuma,
+          neuma: (capture(:attribute) ? [ nil ] : []) + captures(:attribute).collect(&:value) }.extend Neuma
+      end
+    end
+
+    module NeumaBetweenAnglesAttributes
+      def value
+        { kind: :neuma,
+          neuma: (capture(:simple_attribute) ? [capture(:simple_attribute).value] : []) + captures(:attribute).collect(&:value) }.extend Neuma
+      end
+    end
+
+    module Symbol
+      def value
+        { kind: :value,
+          value: capture(:name).value.to_sym }.extend Neuma
+      end
+    end
+
+    module String
+      def value
+        { kind: :value,
+          value: capture(:everything_except_double_quote).value }.extend Neuma
+      end
+    end
+
+    module Float
+      def value
+        { kind: :value,
+          value: capture(:str).value.to_f }.extend Neuma
+      end
+    end
+
+    module Integer
+      def value
+        { kind: :value,
+          value: capture(:digits).value.to_i }.extend Neuma
+      end
+    end
+
+    module Rational
+      def value
+        { kind: :value,
+          value: capture(:str).value.to_r }.extend Neuma
+      end
+    end
+  end
+
+  def self.register(grammar_path)
+    Citrus.load grammar_path
+  end
+
+  def self.parse(string_or_file, language: nil, decode_with: nil, debug: nil)
+    language ||= Neumalang
+
+    match = nil
+
+    if string_or_file.is_a? String
+      match = language.parse string_or_file
+
+    elsif string_or_file.is_a? File
+      match = language.parse string_or_file.read
+
+    else
+      raise ArgumentError, 'Only String or File allowed to be parsed'
+    end
+
+    match.dump if debug
+
+    serie = match.value
+
+    if decode_with
+      serie.eval do |e|
+        if e[:kind] == :neuma
+          decode_with.decode(e[:neuma])
+        else
+          raise ArgumentError, "Don't know how to convert #{e} to neuma"
+        end
+      end
+    else
+      serie
+    end
+  end
+
+  def self.parse_file(filename, decode_with: nil, debug: nil)
+    File.open filename do |file|
+      parse file, decode_with: decode_with, debug: debug
+    end
+  end
+
+  register File.join(File.dirname(__FILE__), 'neumalang')
+end

data/lib/musa-dsl/neumalang.rb

@@ -0,0 +1,3 @@
+require 'musa-dsl/neumalang/neumalang'
+
+