musa-dsl 0.14.31 → 0.21.4

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

@@ -0,0 +1,21 @@
+grammar Musa::Neumalang::Neumalang::Parser::Grammar::Process
+    include Musa::Neumalang::Neumalang::Parser::Grammar::Vectors
+
+    rule process
+        process_of_vectors | process_of_packed_vectors
+    end
+
+    rule process_of_vectors
+        (first:raw_vector
+            (optional_separation
+                bar optional_separation durations:raw_number optional_separation bar optional_separation
+                rest:raw_vector)+) <Musa::Neumalang::Neumalang::Parser::ProcessOfVectors>
+    end
+
+    rule process_of_packed_vectors
+        (first:raw_packed_vector
+            (optional_separation
+                bar optional_separation durations:raw_number optional_separation bar optional_separation
+                rest:raw_packed_vector)+) <Musa::Neumalang::Neumalang::Parser::ProcessOfVectors>
+    end
+end

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

@@ -0,0 +1,67 @@
+grammar Musa::Neumalang::Neumalang::Parser::Grammar::Terminals
+	rule everything_except_comment
+		~/((\*\/)|(\/\*))/m
+	end
+
+	rule everything_except_braces
+		~/({|})/m
+	end
+
+	rule everything_except_double_quote
+		~/(\")/m
+	end
+
+    rule comment
+        (lcomment complex_comment rcomment)
+    end
+
+    rule complex_comment
+        everything_except_comment? (lcomment complex_comment rcomment)* everything_except_comment?
+    end
+
+    rule attribute_change
+        space | dot | rbracket | rpar | rbrace | eol | eos
+    end
+
+    rule true 'true' end
+    rule false 'false' end
+    rule nil 'nil' end
+
+    rule optional_separation (spaces | comment)* end
+    rule separation (spaces | comment)+ end
+
+	rule double_quote '"' end
+	rule single_quote '\'' end
+	rule dot '.' end
+	rule mid_dot '·' end
+	rule comma ',' end
+	rule colon ':' end
+	rule double_colon '::' end
+	rule bar '|' end
+	rule double_bar '||' end
+	rule asterisk '*' end
+	rule slash '/' end
+	rule lpar '(' end
+	rule rpar ')' end
+	rule lbrace '{' end
+	rule rbrace '}' end
+	rule lbracket '[' end
+	rule rbracket ']' end
+	rule lacute '<' end
+	rule racute '>' end
+	rule at '@' end
+	rule ampersand '&' end
+	rule equal '=' end
+	rule lcomment '/*' end
+	rule rcomment '*/' end
+	rule hsh '#' end
+	rule underscore '_' end
+	rule minus '-' end
+	rule plus '+' end
+
+	rule eol /$/ end
+	rule eos /\Z/ end
+
+    rule space /[[:space:]]/ end
+	rule spaces /[[:space:]]/+ end
+end

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

@@ -0,0 +1,23 @@
+grammar Musa::Neumalang::Neumalang::Parser::Grammar::Vectors
+    include Musa::Neumalang::Neumalang::Parser::Grammar::Datatypes
+
+	rule vector
+	    (optional_separation raw_vector) <Musa::Neumalang::Neumalang::Parser::Vector>
+	end
+
+	rule raw_vector
+	    (lpar (optional_separation raw_number)+ optional_separation rpar) <Musa::Neumalang::Neumalang::Parser::RawVector>
+	end
+
+	rule packed_vector
+	    (optional_separation raw_packed_vector) <Musa::Neumalang::Neumalang::Parser::PackedVector>
+	end
+
+	rule raw_packed_vector
+	    (lpar (optional_separation key_value)+ optional_separation rpar) <Musa::Neumalang::Neumalang::Parser::RawPackedVector>
+	end
+
+    rule key_value
+        (raw_symbol colon optional_separation raw_number) { [ capture(:raw_symbol).value, capture(:raw_number).value ] }
+    end
+end

data/lib/musa-dsl/neumas.rb

@@ -0,0 +1,5 @@
+require_relative 'neumas/neuma-gdv-decoder'
+require_relative 'neumas/neuma-gdvd-decoder'
+
+require_relative 'neumas/array-to-neumas'
+require_relative 'neumas/string-to-neumas'

data/lib/musa-dsl/neumas/array-to-neumas.rb

@@ -0,0 +1,34 @@
+require_relative '../series'
+require_relative '../neumalang'
+
+module Musa
+  module Extension
+    module Neumas
+      refine Array do
+        def to_neumas
+          if length > 1
+            MERGE(*collect { |e| convert_to_neumas(e) })
+          else
+            convert_to_neumas(first)
+          end
+        end
+
+        alias_method :neumas, :to_neumas
+        alias_method :n, :to_neumas
+
+        private
+
+        def convert_to_neumas(e)
+          case e
+          when Musa::Neumas::Neuma::Serie then e
+          when Musa::Neumas::Neuma::Parallel then _SE([e], extends: Musa::Neumas::Neuma::Serie)
+          when String then e.to_neumas
+          else
+            raise ArgumentError, "Don't know how to convert to neumas #{e}"
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,63 @@
+require_relative 'neumas'
+
+module Musa::Neumas
+  module Decoders
+    class ProtoDecoder
+      def subcontext
+        self
+      end
+
+      def decode(_element)
+        raise NotImplementedError
+      end
+    end
+
+    class DifferentialDecoder < ProtoDecoder
+      def decode(gdvd)
+        process gdvd
+      end
+
+      def process(_gdvd)
+        raise NotImplementedError
+      end
+    end
+
+    class Decoder < DifferentialDecoder
+      def initialize(base, transcriptor: nil)
+        @base = base
+        @last = base.clone
+
+        @transcriptor = transcriptor
+      end
+
+      attr_accessor :transcriptor
+      attr_reader :base
+
+      def base=(base)
+        @base = base
+        @last = base.clone
+      end
+
+      def subcontext
+        Decoder.new @base
+      end
+
+      def decode(attributes)
+        result = apply process(attributes), on: @last
+
+        @last = result.clone
+
+        if @transcriptor
+          @transcriptor.transcript(result)
+        else
+          result
+        end
+      end
+
+      def apply(_action, on:)
+        raise NotImplementedError
+      end
+    end
+  end
+end
+

data/lib/musa-dsl/neumas/neuma-gdv-decoder.rb

@@ -0,0 +1,57 @@
+require_relative 'neuma-decoder'
+
+module Musa::Neumas
+  module Decoders
+    class NeumaDecoder < Decoder # to get a GDV
+      def initialize(scale, base_duration: nil, transcriptor: nil, base: nil)
+        @base_duration = base_duration
+        @base_duration ||= base[:duration] if base
+        @base_duration ||= Rational(1,4)
+
+        base ||= { grade: 0, octave: 0, duration: @base_duration, velocity: 1 }
+
+        @scale = scale
+
+        super base, transcriptor: transcriptor
+      end
+
+      attr_accessor :scale, :base_duration
+
+      def process(gdvd)
+        gdvd = gdvd.clone
+
+        gdvd.base_duration = @base_duration
+
+        appogiatura_gdvd = gdvd[:modifiers]&.delete :appogiatura
+
+        if appogiatura_gdvd
+          appogiatura_gdvd = appogiatura_gdvd.clone
+          appogiatura_gdvd.base_duration = @base_duration
+
+          gdvd[:modifiers][:appogiatura] = appogiatura_gdvd
+        end
+
+        gdvd
+      end
+
+      def subcontext
+        NeumaDecoder.new @scale, base_duration: @base_duration, transcriptor: @transcriptor, base: @last
+      end
+
+      def apply(gdvd, on:)
+        gdv = gdvd.to_gdv @scale, previous: on
+
+        appogiatura_action = gdvd.dig(:modifiers, :appogiatura)
+        gdv[:appogiatura] = appogiatura_action.to_gdv @scale, previous: on if appogiatura_action
+
+        gdv
+      end
+
+      def inspect
+        "GDV NeumaDecoder: @last = #{@last}"
+      end
+
+      alias to_s inspect
+    end
+  end
+end

data/lib/musa-dsl/neumas/neuma-gdvd-decoder.rb

@@ -0,0 +1,15 @@
+require_relative 'neuma-decoder'
+
+module Musa::Neumas
+  module Decoders
+    class NeumaDifferentialDecoder < DifferentialDecoder # to get a GDVd
+      def initialize(base_duration: nil)
+        @base_duration = base_duration || Rational(1,4)
+      end
+
+      def process(gdvd)
+        gdvd.clone.tap { |_| _.base_duration = @base_duration }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require_relative 'string-to-neumas'
+
+using Musa::Extension::Neumas
+
+module Musa
+  module Neumas
+    module Neuma
+      module Parallel
+        include Neuma
+      end
+
+      module Serie
+        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, "Don't know how to convert to neumas #{e}"
+        end
+      end
+    end
+  end
+end

data/lib/musa-dsl/neumas/string-to-neumas.rb

@@ -0,0 +1,34 @@
+require_relative '../neumalang'
+require_relative '../generative/generative-grammar'
+
+module Musa
+  module Extension
+    module Neumas
+      refine String do
+        def to_neumas(decode_with: nil, debug: nil)
+          Musa::Neumalang::Neumalang.parse(self, decode_with: decode_with, debug: debug)
+        end
+
+        def to_neumas_to_node(decode_with: nil, debug: nil)
+          to_neumas(decode_with: decode_with, debug: debug).to_node
+        end
+
+        def |(other)
+          case other
+          when String
+            { kind: :parallel,
+              parallel: [{ kind: :serie, serie: self.to_neumas },
+                         { kind: :serie, serie: other.to_neumas }] }.extend(Musa::Neumas::Neuma::Parallel)
+          else
+            raise ArgumentError, "Don't know how to parallelize #{other}"
+          end
+        end
+
+
+        alias_method :neumas, :to_neumas
+        alias_method :n, :to_neumas
+        alias_method :nn, :to_neumas_to_node
+      end
+    end
+  end
+end

data/lib/musa-dsl/repl.rb

@@ -1 +1 @@
-require 'musa-dsl/repl/repl'
+require_relative 'repl/repl'

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

@@ -1,149 +1,161 @@
 require 'socket'
 
 module Musa
-  class REPL
-    @@repl_mutex = Mutex.new
+  module REPL
+    class REPL
+      @@repl_mutex = Mutex.new
 
-    def initialize(binder, port: nil, redirect_stderr: nil, after_eval: nil)
-      port ||= 1327
-      redirect_stderr ||= false
+      def initialize(binder, port: nil, after_eval: nil, logger: nil)
+        port ||= 1327
 
-      @block_source = nil
+        @logger = logger || Musa::Logger::Logger.new
 
-      if binder.receiver.respond_to?(:sequencer) &&
-         binder.receiver.sequencer.respond_to?(:on_block_error)
+        @block_source = nil
 
-        binder.receiver.sequencer.on_block_error do |e|
-          send_exception e
+        if binder.receiver.respond_to?(:sequencer) &&
+            binder.receiver.sequencer.respond_to?(:on_error)
+
+          binder.receiver.sequencer.on_error do |e|
+            send_exception e, output: @connection
+          end
         end
-      end
 
-      @client_threads = []
-      @run = true
-
-      @main_thread = Thread.new do
-        @server = TCPServer.new(port)
-        begin
-          while (connection = @server.accept) && @run
-            @client_threads << Thread.new do
-              buffer = nil
-
-              begin
-                while (line = connection.gets) && @run
-                  line.chomp!
-                  case line
-                  when '#begin'
-                    buffer = StringIO.new
-                  when '#end'
-                    @@repl_mutex.synchronize do
-                      original_stdout = $stdout
-                      original_stderr = $stderr
-
-                      $stdout = connection
-                      $stderr = connection if redirect_stderr
-
-                      @block_source = buffer.string
-
-                      begin
-                        send_echo @block_source
-
-                        binder.eval @block_source, "(repl)", 1
-                      rescue StandardError, ScriptError => e
-                        send_exception e
-                      else
-                        after_eval.call @block_source if after_eval
-                      end
+        @client_threads = []
+        @run = true
+
+        @main_thread = Thread.new do
+          @server = TCPServer.new(port)
+          begin
+            while (@connection = @server.accept) && @run
+              @client_threads << Thread.new do
+                buffer = nil
+
+                begin
+                  while (line = @connection.gets) && @run
+
+                    @logger.warn('REPL') { 'input line is nil; will close connection...' } if line.nil?
+
+                    line.chomp!
+                    case line
+                    when '#begin'
+                      buffer = StringIO.new
 
-                      $stdout = original_stdout
-                      $stderr = original_stderr if redirect_stderr
+                    when '#end'
+                      @@repl_mutex.synchronize do
+                        @block_source = buffer.string
+
+                        begin
+                          send_echo @block_source, output: @connection
+                          binder.eval @block_source, "(repl)", 1
+
+                        rescue StandardError, ScriptError => e
+                          @logger.warn('REPL') { 'code execution error' }
+                          @logger.warn('REPL') { e.full_message(highlight: true, order: :top) }
+
+                          send_exception e, output: @connection
+                        else
+                          after_eval.call @block_source if after_eval
+                        end
+                      end
+                    else
+                      buffer.puts line
                     end
-                  else
-                    buffer.puts line
                   end
+
+                rescue IOError, Errno::ECONNRESET, Errno::EPIPE => e
+                  @logger.warn('REPL') { 'lost connection' }
+                  @logger.warn('REPL') { e.full_message(highlight: true, order: :top) }
+
+                ensure
+                  @logger.debug("REPL") { "closing connection (running #{@run})" }
+                  @connection.close
                 end
-              rescue IOError, Errno::ECONNRESET, Errno::EPIPE => e
-                warn e.message
-              end
 
-              connection.close
+              end
             end
+          rescue Errno::ECONNRESET, Errno::EPIPE => e
+            @logger.warn('REPL') { 'connection failure while getting server port; will retry...' }
+            @logger.warn('REPL') { e.full_message(highlight: true, order: :top) }
+            retry
+
           end
-        rescue Errno::ECONNRESET, Errno::EPIPE => e
-          warn e.message
-          retry
         end
       end
-    end
 
-    def stop
-      @run = false
+      def stop
+        @run = false
 
-      @main_thread.terminate
-      @client_threads.each { |t| t.terminate }
+        @main_thread.terminate
+        Thread.pass
 
-      @main_thread = nil
-      @client_threads.clear
-    end
+        @main_thread = nil
 
-    private
+        @client_threads.each { |t| t.terminate; Thread.pass }
+        @client_threads.clear
+      end
 
-    def send_echo(e)
-      send command: '//echo'
-      send content: e
-      send command: '//end'
-    end
+      private
+
+      def send_echo(e, output:)
+        send output: output, command: '//echo'
+        send output: output, content: e
+        send output: output, command: '//end'
+      end
+
+      def send_exception(e, output:)
 
-    def send_exception(e)
+        @logger.error('REPL') { e.full_message(highlight: true, order: :top) }
 
-      send command: '//error'
+        send output: output, command: '//error'
 
-      selected_backtrace_locations = e.backtrace_locations.select { |bt| bt.path == '(repl)' }
+        selected_backtrace_locations = e.backtrace_locations.select { |bt| bt.path == '(repl)' }
 
-      if e.is_a?(ScriptError)
-        send content: e.class.name
-        send command: '//backtrace'
-        send content: e.message
+        if e.is_a?(ScriptError)
+          send output: output, content: e.class.name
+          send output: output, command: '//backtrace'
+          send output: output, content: e.message
 
-      elsif selected_backtrace_locations.empty?
-        send content: "#{e.class.name}: #{e.message}"
-        send command: '//backtrace'
-        send content: e.backtrace_locations.first.to_s
+        elsif selected_backtrace_locations.empty?
+          send output: output, content: "#{e.class.name}: #{e.message}"
+          send output: output, command: '//backtrace'
+          send output: output, content: e.backtrace_locations.first.to_s
 
-      else
-        lines = @block_source.split("\n")
+        else
+          lines = @block_source.split("\n")
 
-        lineno = selected_backtrace_locations.first.lineno
+          lineno = selected_backtrace_locations.first.lineno
 
-        source_before = lines[lineno - 2] if lineno >= 2
-        source_error = lines[lineno - 1]
-        source_after = lines[lineno]
+          source_before = lines[lineno - 2] if lineno >= 2
+          source_error = lines[lineno - 1]
+          source_after = lines[lineno]
 
-        send content: '***'
-        send content: "[#{lineno - 1}] #{source_before}" if source_before
-        send content: "[#{lineno}] #{source_error} \t\t<<< ERROR !!!"
-        send content: "[#{lineno + 1}] #{source_after}" if source_after
-        send content: '***'
-        send content: e.class.name
-        send content: e.message
-        send command: '//backtrace'
-        selected_backtrace_locations.each do |bt|
-          send content: bt.to_s
+          send output: output, content: '***'
+          send output: output, content: "[#{lineno - 1}] #{source_before}" if source_before
+          send output: output, content: "[#{lineno}] #{source_error} \t\t<<< ERROR !!!"
+          send output: output, content: "[#{lineno + 1}] #{source_after}" if source_after
+          send output: output, content: '***'
+          send output: output, content: e.class.name
+          send output: output, content: e.message
+          send output: output, command: '//backtrace'
+          selected_backtrace_locations.each do |bt|
+            send output: output, content: bt.to_s
+          end
         end
+        send output: output, content: ' '
+        send output: output, command: '//end'
       end
-      send content: ' '
-      send command: '//end'
-    end
 
-    def send(content: nil, command: nil)
-      puts escape(content) if content
-      puts command if command
-    end
+      def send(output:, content: nil, command: nil)
+        output.puts escape(content) if content
+        output.puts command if command
+      end
 
-    def escape(text)
-      if text.start_with? '//'
-        "//#{text}"
-      else
-        text
+      def escape(text)
+        if text.start_with? '//'
+          "//#{text}"
+        else
+          text
+        end
       end
     end
   end